├── nmake.bat ├── bench ├── samples │ ├── inline-backticks.md │ ├── block-hr.md │ ├── block-code.md │ ├── block-fences.md │ ├── block-lheading.md │ ├── block-heading.md │ ├── inline-em-flat.md │ ├── inline-em-nested.md │ ├── inline-em-worst.md │ ├── inline-escape.md │ ├── inline-newlines.md │ ├── block-bq-flat.md │ ├── block-ref-nested.md │ ├── rawtabs.md │ ├── inline-entity.md │ ├── inline-links-nested.md │ ├── block-bq-nested.md │ ├── block-html.md │ ├── block-ref-flat.md │ ├── block-list-nested.md │ ├── inline-autolink.md │ ├── inline-html.md │ ├── inline-links-flat.md │ ├── block-list-flat.md │ └── lorem1.md └── stats.py ├── wrappers ├── wrapper.js ├── wrapper.rb ├── wrapper.py └── wrapper_ext.py ├── suppressions ├── extensions ├── tasklist.h ├── autolink.h ├── tagfilter.h ├── strikethrough.h ├── table.h ├── ext_scanners.h ├── core-extensions.c ├── tagfilter.c ├── cmark-gfm-core-extensions.h ├── ext_scanners.re ├── CMakeLists.txt ├── tasklist.c └── strikethrough.c ├── test ├── run-cmark-fuzz ├── afl_test_cases │ └── test.md ├── extensions-table-prefer-style-attributes.txt ├── fuzzing_dictionary ├── extensions-full-info-string.txt ├── cmark-fuzz.c ├── entity_tests.py ├── roundtrip_tests.py ├── cmark.py ├── CMakeLists.txt ├── smart_punct.txt └── pathological_tests.py ├── api_test ├── cplusplus.h ├── cplusplus.cpp ├── harness.h ├── CMakeLists.txt └── harness.c ├── man ├── CMakeLists.txt ├── man1 │ └── cmark-gfm.1 └── make_man_page.py ├── tools ├── appveyor-build.bat ├── mkcasefold.pl ├── Dockerfile ├── make_entities_inc.py └── xml2md_gfm.xsl ├── .editorconfig ├── CheckFileOffsetBits.c ├── src ├── cmark-gfm_version.h.in ├── libcmark-gfm.pc.in ├── iterator.h ├── registry.h ├── footnotes.h ├── references.h ├── plugin.h ├── cmark_ctype.h ├── html.h ├── utf8.h ├── inlines.h ├── linked_list.c ├── map.h ├── plugin.c ├── references.c ├── syntax_extension.h ├── cmark.c ├── config.h.in ├── houdini.h ├── registry.c ├── cmark_ctype.c ├── render.h ├── footnotes.c ├── parser.h ├── houdini_html_e.c ├── arena.c ├── buffer.h ├── houdini_href_e.c ├── map.c ├── scanners.h ├── chunk.h ├── houdini_html_u.c ├── node.h ├── iterator.c ├── syntax_extension.c ├── xml.c └── plaintext.c ├── fuzz ├── README.md ├── CMakeLists.txt ├── fuzzloop.sh ├── fuzz_quadratic.c └── fuzz_quadratic_brackets.c ├── appveyor.yml ├── .gitignore ├── toolchain-mingw32.cmake ├── .travis.yml ├── Makefile.nmake ├── benchmarks.md ├── CMakeLists.txt ├── .github └── workflows │ ├── ci.yml │ └── codeql.yml ├── CheckFileOffsetBits.cmake ├── why-cmark-and-not-x.md └── FindAsan.cmake /nmake.bat: -------------------------------------------------------------------------------- 1 | @nmake.exe /nologo /f Makefile.nmake %* 2 | -------------------------------------------------------------------------------- /bench/samples/inline-backticks.md: -------------------------------------------------------------------------------- 1 | `lots`of`backticks` 2 | 3 | ``i``wonder``how``this``will``be``parsed`` 4 | -------------------------------------------------------------------------------- /wrappers/wrapper.js: -------------------------------------------------------------------------------- 1 | 2 | const cmark = require('node-cmark'); 3 | 4 | const markdown = '# h1 title'; 5 | 6 | cmark.markdown2html(markdown); 7 | -------------------------------------------------------------------------------- /bench/samples/block-hr.md: -------------------------------------------------------------------------------- 1 | 2 | * * * * * 3 | 4 | - - - - - 5 | 6 | ________ 7 | 8 | 9 | ************************* text 10 | 11 | -------------------------------------------------------------------------------- /bench/samples/block-code.md: -------------------------------------------------------------------------------- 1 | 2 | an 3 | example 4 | 5 | of 6 | 7 | 8 | 9 | a code 10 | block 11 | 12 | -------------------------------------------------------------------------------- /bench/samples/block-fences.md: -------------------------------------------------------------------------------- 1 | 2 | ``````````text 3 | an 4 | example 5 | ``` 6 | of 7 | 8 | 9 | a fenced 10 | ``` 11 | code 12 | block 13 | `````````` 14 | 15 | -------------------------------------------------------------------------------- /bench/samples/block-lheading.md: -------------------------------------------------------------------------------- 1 | heading 2 | --- 3 | 4 | heading 5 | =================================== 6 | 7 | not a heading 8 | ----------------------------------- text 9 | -------------------------------------------------------------------------------- /suppressions: -------------------------------------------------------------------------------- 1 | { 2 | . 3 | Memcheck:Leak 4 | fun:malloc 5 | fun:__smakebuf 6 | fun:__srefill0 7 | fun:__fread 8 | fun:fread 9 | fun:main 10 | } 11 | -------------------------------------------------------------------------------- /extensions/tasklist.h: -------------------------------------------------------------------------------- 1 | #ifndef TASKLIST_H 2 | #define TASKLIST_H 3 | 4 | #include "cmark-gfm-core-extensions.h" 5 | 6 | cmark_syntax_extension *create_tasklist_extension(void); 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /bench/samples/block-heading.md: -------------------------------------------------------------------------------- 1 | # heading 2 | ### heading 3 | ##### heading 4 | 5 | # heading # 6 | ### heading ### 7 | ##### heading \#\#\#\#\###### 8 | 9 | ############ not a heading 10 | -------------------------------------------------------------------------------- /test/run-cmark-fuzz: -------------------------------------------------------------------------------- 1 | #!/bin/bash -eu 2 | CMARK_FUZZ="$1" 3 | shift 4 | ASAN_OPTIONS="quarantine_size_mb=10:detect_leaks=1" "${CMARK_FUZZ}" -max_len=256 -timeout=1 -dict=test/fuzzing_dictionary "$@" 5 | -------------------------------------------------------------------------------- /bench/samples/inline-em-flat.md: -------------------------------------------------------------------------------- 1 | *this* *is* *your* *basic* *boring* *emphasis* 2 | 3 | _this_ _is_ _your_ _basic_ _boring_ _emphasis_ 4 | 5 | **this** **is** **your** **basic** **boring** **emphasis** 6 | -------------------------------------------------------------------------------- /bench/samples/inline-em-nested.md: -------------------------------------------------------------------------------- 1 | *this *is *a *bunch* of* nested* emphases* 2 | 3 | __this __is __a __bunch__ of__ nested__ emphases__ 4 | 5 | ***this ***is ***a ***bunch*** of*** nested*** emphases*** 6 | -------------------------------------------------------------------------------- /extensions/autolink.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_GFM_AUTOLINK_H 2 | #define CMARK_GFM_AUTOLINK_H 3 | 4 | #include "cmark-gfm-core-extensions.h" 5 | 6 | cmark_syntax_extension *create_autolink_extension(void); 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /extensions/tagfilter.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_GFM_TAGFILTER_H 2 | #define CMARK_GFM_TAGFILTER_H 3 | 4 | #include "cmark-gfm-core-extensions.h" 5 | 6 | cmark_syntax_extension *create_tagfilter_extension(void); 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /bench/samples/inline-em-worst.md: -------------------------------------------------------------------------------- 1 | *this *is *a *worst *case *for *em *backtracking 2 | 3 | __this __is __a __worst __case __for __em __backtracking 4 | 5 | ***this ***is ***a ***worst ***case ***for ***em ***backtracking 6 | -------------------------------------------------------------------------------- /bench/samples/inline-escape.md: -------------------------------------------------------------------------------- 1 | 2 | \t\e\s\t\i\n\g \e\s\c\a\p\e \s\e\q\u\e\n\c\e\s 3 | 4 | \!\\\"\#\$\%\&\'\(\)\*\+\,\.\/\:\;\<\=\>\? 5 | 6 | \@ \[ \] \^ \_ \` \{ \| \} \~ \- \' 7 | 8 | \ 9 | \\ 10 | \\\ 11 | \\\\ 12 | \\\\\ 13 | 14 | \ \ \ \ 15 | 16 | -------------------------------------------------------------------------------- /bench/samples/inline-newlines.md: -------------------------------------------------------------------------------- 1 | 2 | this\ 3 | should\ 4 | be\ 5 | separated\ 6 | by\ 7 | newlines 8 | 9 | this 10 | should 11 | be 12 | separated 13 | by 14 | newlines 15 | too 16 | 17 | this 18 | should 19 | not 20 | be 21 | separated 22 | by 23 | newlines 24 | 25 | -------------------------------------------------------------------------------- /extensions/strikethrough.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_GFM_STRIKETHROUGH_H 2 | #define CMARK_GFM_STRIKETHROUGH_H 3 | 4 | #include "cmark-gfm-core-extensions.h" 5 | 6 | extern cmark_node_type CMARK_NODE_STRIKETHROUGH; 7 | cmark_syntax_extension *create_strikethrough_extension(void); 8 | 9 | #endif 10 | -------------------------------------------------------------------------------- /api_test/cplusplus.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_API_TEST_CPLUSPLUS_H 2 | #define CMARK_API_TEST_CPLUSPLUS_H 3 | 4 | #include "harness.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | void test_cplusplus(test_batch_runner *runner); 11 | 12 | #ifdef __cplusplus 13 | } 14 | #endif 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /extensions/table.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_GFM_TABLE_H 2 | #define CMARK_GFM_TABLE_H 3 | 4 | #include "cmark-gfm-core-extensions.h" 5 | 6 | 7 | extern cmark_node_type CMARK_NODE_TABLE, CMARK_NODE_TABLE_ROW, 8 | CMARK_NODE_TABLE_CELL; 9 | 10 | cmark_syntax_extension *create_table_extension(void); 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /man/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if (NOT MSVC) 2 | 3 | include(GNUInstallDirs) 4 | 5 | install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/man1/cmark-gfm.1 6 | DESTINATION ${CMAKE_INSTALL_MANDIR}/man1) 7 | 8 | install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/man3/cmark-gfm.3 9 | DESTINATION ${CMAKE_INSTALL_MANDIR}/man3) 10 | endif(NOT MSVC) 11 | -------------------------------------------------------------------------------- /tools/appveyor-build.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | 3 | if "%MSVC_VERSION%" == "10" goto msvc10 4 | 5 | call "C:\Program Files (x86)\Microsoft Visual Studio %MSVC_VERSION%.0\VC\vcvarsall.bat" amd64 6 | goto build 7 | 8 | :msvc10 9 | call "C:\Program Files\Microsoft SDKs\Windows\v7.1\Bin\SetEnv.cmd" /x64 10 | 11 | :build 12 | nmake 13 | 14 | -------------------------------------------------------------------------------- /bench/samples/block-bq-flat.md: -------------------------------------------------------------------------------- 1 | > the simple example of a blockquote 2 | > the simple example of a blockquote 3 | > the simple example of a blockquote 4 | > the simple example of a blockquote 5 | ... continuation 6 | ... continuation 7 | ... continuation 8 | ... continuation 9 | 10 | empty blockquote: 11 | 12 | > 13 | > 14 | > 15 | > 16 | 17 | -------------------------------------------------------------------------------- /.editorconfig: -------------------------------------------------------------------------------- 1 | # editorconfig.org 2 | 3 | root = true 4 | 5 | [*] 6 | end_of_line = lf 7 | charset = utf-8 8 | insert_final_newline = true 9 | 10 | [*.{c,h}] 11 | trim_trailing_whitespace = true 12 | indent_style = space 13 | indent_size = 2 14 | 15 | [Makefile] 16 | trim_trailing_whitespace = true 17 | indent_style = tab 18 | indent_size = 8 19 | -------------------------------------------------------------------------------- /bench/samples/block-ref-nested.md: -------------------------------------------------------------------------------- 1 | [[[[[[[foo]]]]]]] 2 | 3 | [[[[[[[foo]]]]]]]: bar 4 | [[[[[[foo]]]]]]: bar 5 | [[[[[foo]]]]]: bar 6 | [[[[foo]]]]: bar 7 | [[[foo]]]: bar 8 | [[foo]]: bar 9 | [foo]: bar 10 | 11 | [*[*[*[*[foo]*]*]*]*] 12 | 13 | [*[*[*[*[foo]*]*]*]*]: bar 14 | [*[*[*[foo]*]*]*]: bar 15 | [*[*[foo]*]*]: bar 16 | [*[foo]*]: bar 17 | [foo]: bar 18 | -------------------------------------------------------------------------------- /CheckFileOffsetBits.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define KB ((off_t)1024) 4 | #define MB ((off_t)1024 * KB) 5 | #define GB ((off_t)1024 * MB) 6 | #define TB ((off_t)1024 * GB) 7 | int t2[(((64 * GB -1) % 671088649) == 268434537) 8 | && (((TB - (64 * GB -1) + 255) % 1792151290) == 305159546)? 1: -1]; 9 | 10 | int main() 11 | { 12 | ; 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /src/cmark-gfm_version.h.in: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_GFM_VERSION_H 2 | #define CMARK_GFM_VERSION_H 3 | 4 | #define CMARK_GFM_VERSION ((@PROJECT_VERSION_MAJOR@ << 24) | (@PROJECT_VERSION_MINOR@ << 16) | (@PROJECT_VERSION_PATCH@ << 8) | @PROJECT_VERSION_GFM@) 5 | #define CMARK_GFM_VERSION_STRING "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@.gfm.@PROJECT_VERSION_GFM@" 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /bench/samples/rawtabs.md: -------------------------------------------------------------------------------- 1 | 2 | this is a test for tab expansion, be careful not to replace them with spaces 3 | 4 | 1 4444 5 | 22 333 6 | 333 22 7 | 4444 1 8 | 9 | 10 | tab-indented line 11 | space-indented line 12 | tab-indented line 13 | 14 | 15 | a lot of spaces in between here 16 | 17 | a lot of tabs in between here 18 | 19 | -------------------------------------------------------------------------------- /wrappers/wrapper.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | require 'ffi' 3 | 4 | module CMark 5 | extend FFI::Library 6 | ffi_lib ['libcmark', 'cmark'] 7 | attach_function :cmark_markdown_to_html, [:string, :int, :int], :string 8 | end 9 | 10 | def markdown_to_html(s) 11 | len = s.bytesize 12 | CMark::cmark_markdown_to_html(s, len, 0) 13 | end 14 | 15 | STDOUT.write(markdown_to_html(ARGF.read())) 16 | -------------------------------------------------------------------------------- /bench/samples/inline-entity.md: -------------------------------------------------------------------------------- 1 | entities: 2 | 3 |   & © Æ Ď ¾ ℋ ⅆ ∲ 4 | 5 | # Ӓ Ϡ � 6 | 7 | non-entities: 8 | 9 | &18900987654321234567890; &1234567890098765432123456789009876543212345678987654; 10 | 11 | &qwertyuioppoiuytrewqwer; &oiuytrewqwertyuioiuytrewqwertyuioytrewqwertyuiiuytri; 12 | -------------------------------------------------------------------------------- /bench/samples/inline-links-nested.md: -------------------------------------------------------------------------------- 1 | Valid links: 2 | 3 | [[[[[[[[](test)](test)](test)](test)](test)](test)](test)] 4 | 5 | [ [[[[[[[[[[[[[[[[[[ [](test) ]]]]]]]]]]]]]]]]]] ](test) 6 | 7 | Invalid links: 8 | 9 | [[[[[[[[[ 10 | 11 | [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ 12 | 13 | ![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![![ 14 | -------------------------------------------------------------------------------- /src/libcmark-gfm.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@CMAKE_INSTALL_PREFIX@ 2 | exec_prefix=@CMAKE_INSTALL_PREFIX@ 3 | libdir=@CMAKE_INSTALL_PREFIX@/@libdir@ 4 | includedir=@CMAKE_INSTALL_PREFIX@/include 5 | 6 | Name: libcmark-gfm 7 | Description: CommonMark parsing, rendering, and manipulation with GitHub Flavored Markdown extensions 8 | Version: @PROJECT_VERSION@ 9 | Libs: -L${libdir} -lcmark-gfm -lcmark-gfm-extensions 10 | Cflags: -I${includedir} 11 | -------------------------------------------------------------------------------- /api_test/cplusplus.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "cmark-gfm.h" 4 | #include "cplusplus.h" 5 | #include "harness.h" 6 | 7 | void 8 | test_cplusplus(test_batch_runner *runner) 9 | { 10 | static const char md[] = "paragraph\n"; 11 | char *html = cmark_markdown_to_html(md, sizeof(md) - 1, CMARK_OPT_DEFAULT); 12 | STR_EQ(runner, html, "

paragraph

\n", "libcmark works with C++"); 13 | free(html); 14 | } 15 | 16 | -------------------------------------------------------------------------------- /bench/samples/block-bq-nested.md: -------------------------------------------------------------------------------- 1 | >>>>>> deeply nested blockquote 2 | >>>>> deeply nested blockquote 3 | >>>> deeply nested blockquote 4 | >>> deeply nested blockquote 5 | >> deeply nested blockquote 6 | > deeply nested blockquote 7 | 8 | > deeply nested blockquote 9 | >> deeply nested blockquote 10 | >>> deeply nested blockquote 11 | >>>> deeply nested blockquote 12 | >>>>> deeply nested blockquote 13 | >>>>>> deeply nested blockquote 14 | -------------------------------------------------------------------------------- /fuzz/README.md: -------------------------------------------------------------------------------- 1 | The quadratic fuzzer generates long sequences of repeated characters, such as ` 2 | 3 | blah blah 4 | 5 | 6 | 7 | 8 | 9 | 12 | 13 |
10 | **test** 11 |
14 | 15 | 16 | 17 | 18 | 19 | 24 | 25 | 26 | 27 |
20 | 21 | test 22 | 23 |
28 | 29 | 32 | 33 | -------------------------------------------------------------------------------- /appveyor.yml: -------------------------------------------------------------------------------- 1 | environment: 2 | PYTHON: "C:\\Python34-x64" 3 | PYTHON_VERSION: "3.4.3" 4 | PYTHON_ARCH: "64" 5 | matrix: 6 | - MSVC_VERSION: 10 7 | - MSVC_VERSION: 12 8 | 9 | # set up for nmake: 10 | install: 11 | - "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%" 12 | 13 | build_script: 14 | - 'tools\appveyor-build.bat' 15 | 16 | artifacts: 17 | - path: build/src/cmark-gfm.exe 18 | name: cmark-gfm.exe 19 | 20 | test_script: 21 | - 'nmake test' 22 | -------------------------------------------------------------------------------- /src/iterator.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_ITERATOR_H 2 | #define CMARK_ITERATOR_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #include "cmark-gfm.h" 9 | 10 | typedef struct { 11 | cmark_event_type ev_type; 12 | cmark_node *node; 13 | } cmark_iter_state; 14 | 15 | struct cmark_iter { 16 | cmark_mem *mem; 17 | cmark_node *root; 18 | cmark_iter_state cur; 19 | cmark_iter_state next; 20 | }; 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /src/registry.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_REGISTRY_H 2 | #define CMARK_REGISTRY_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #include "cmark-gfm.h" 9 | #include "plugin.h" 10 | 11 | CMARK_GFM_EXPORT 12 | void cmark_register_plugin(cmark_plugin_init_func reg_fn); 13 | 14 | CMARK_GFM_EXPORT 15 | void cmark_release_plugins(void); 16 | 17 | CMARK_GFM_EXPORT 18 | cmark_llist *cmark_list_syntax_extensions(cmark_mem *mem); 19 | 20 | #ifdef __cplusplus 21 | } 22 | #endif 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Object files 2 | *.o 3 | *.ko 4 | *.obj 5 | *.elf 6 | 7 | # Libraries 8 | *.lib 9 | *.a 10 | 11 | # Shared objects (inc. Windows DLLs) 12 | *.dll 13 | *.so 14 | *.so.* 15 | *.dylib 16 | 17 | # Executables 18 | *.exe 19 | *.out 20 | *.app 21 | *.i*86 22 | *.x86_64 23 | *.hex 24 | *.pyc 25 | 26 | *~ 27 | *.bak 28 | *.diff 29 | *# 30 | *.zip 31 | bstrlib.txt 32 | build 33 | cmark.dSYM/* 34 | cmark 35 | .vscode 36 | .DS_Store 37 | 38 | # Testing and benchmark 39 | alltests.md 40 | progit/ 41 | bench/benchinput.md 42 | test/afl_results/ 43 | -------------------------------------------------------------------------------- /bench/samples/block-ref-flat.md: -------------------------------------------------------------------------------- 1 | [1] [2] [3] [1] [2] [3] 2 | 3 | [looooooooooooooooooooooooooooooooooooooooooooooooooong label] 4 | 5 | [1]: 6 | [2]: http://something.example.com/foo/bar 'test' 7 | [3]: 8 | http://foo/bar 9 | [ looooooooooooooooooooooooooooooooooooooooooooooooooong label ]: 10 | 111 11 | 'test' 12 | [[[[[[[[[[[[[[[[[[[[ this should not slow down anything ]]]]]]]]]]]]]]]]]]]]: q 13 | (as long as it is not referenced anywhere) 14 | 15 | [[[[[[[[[[[[[[[[[[[[]: this is not a valid reference 16 | -------------------------------------------------------------------------------- /bench/stats.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import sys 4 | import statistics 5 | 6 | def pairs(l, n): 7 | return zip(*[l[i::n] for i in range(n)]) 8 | 9 | # data comes in pairs: 10 | # n - time for running the program with no input 11 | # m - time for running it with the benchmark input 12 | # we measure (m - n) 13 | 14 | values = [ float(y) - float(x) for (x,y) in pairs(sys.stdin.readlines(),2)] 15 | 16 | print("mean = %.4f, median = %.4f, stdev = %.4f" % 17 | (statistics.mean(values), statistics.median(values), 18 | statistics.stdev(values))) 19 | 20 | -------------------------------------------------------------------------------- /src/footnotes.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_FOOTNOTES_H 2 | #define CMARK_FOOTNOTES_H 3 | 4 | #include "map.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | struct cmark_footnote { 11 | cmark_map_entry entry; 12 | cmark_node *node; 13 | unsigned int ix; 14 | }; 15 | 16 | typedef struct cmark_footnote cmark_footnote; 17 | 18 | void cmark_footnote_create(cmark_map *map, cmark_node *node); 19 | cmark_map *cmark_footnote_map_new(cmark_mem *mem); 20 | 21 | void cmark_unlink_footnotes_map(cmark_map *map); 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /bench/samples/block-list-nested.md: -------------------------------------------------------------------------------- 1 | 2 | - this 3 | - is 4 | - a 5 | - deeply 6 | - nested 7 | - bullet 8 | - list 9 | 10 | 11 | 1. this 12 | 2. is 13 | 3. a 14 | 4. deeply 15 | 5. nested 16 | 6. unordered 17 | 7. list 18 | 19 | 20 | - 1 21 | - 2 22 | - 3 23 | - 4 24 | - 5 25 | - 6 26 | - 7 27 | - 6 28 | - 5 29 | - 4 30 | - 3 31 | - 2 32 | - 1 33 | 34 | 35 | - - - - - - - - - deeply-nested one-element item 36 | 37 | -------------------------------------------------------------------------------- /src/references.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_REFERENCES_H 2 | #define CMARK_REFERENCES_H 3 | 4 | #include "map.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | struct cmark_reference { 11 | cmark_map_entry entry; 12 | cmark_chunk url; 13 | cmark_chunk title; 14 | }; 15 | 16 | typedef struct cmark_reference cmark_reference; 17 | 18 | void cmark_reference_create(cmark_map *map, cmark_chunk *label, 19 | cmark_chunk *url, cmark_chunk *title); 20 | cmark_map *cmark_reference_map_new(cmark_mem *mem); 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /test/afl_test_cases/test.md: -------------------------------------------------------------------------------- 1 | # H1 2 | 3 | H2 4 | -- 5 | 6 | t ☺ 7 | *b* **em** `c` 8 | ≥\&\ 9 | \_e\_ 10 | 11 | 4) I1 12 | 13 | 5) I2 14 | > [l](/u "t") 15 | > 16 | > - [f] 17 | > - ![a](/u "t") 18 | > 19 | >> 20 | >> 21 | 22 | ~~~ l☺ 23 | cb 24 | ~~~ 25 | 26 | c1 27 | c2 28 | 29 | *** 30 | 31 |
32 | x 33 |
34 | 35 | | a | b | 36 | | --- | --- | 37 | | c | `d|` \| e | 38 | 39 | google ~~yahoo~~ 40 | 41 | google.com http://google.com google@google.com 42 | 43 | and but 44 | 45 | <surewhynot> 46 | sure 47 | </surewhynot> 48 | 49 | [f]: /u "t" 50 | -------------------------------------------------------------------------------- /tools/mkcasefold.pl: -------------------------------------------------------------------------------- 1 | binmode STDOUT; 2 | print(" switch (c) {\n"); 3 | my $lastchar = ""; 4 | while (<STDIN>) { 5 | if (/^[A-F0-9]/ and / [CF]; /) { 6 | my ($char, $type, $subst) = m/([A-F0-9]+); ([CF]); ([^;]+)/; 7 | if ($char eq $lastchar) { 8 | break; 9 | } 10 | my @subst = $subst =~ m/(\w+)/g; 11 | printf(" case 0x%s:\n", $char); 12 | foreach (@subst) { 13 | printf(" bufpush(0x%s);\n", $_); 14 | } 15 | printf(" break;\n"); 16 | $lastchar = $char; 17 | } 18 | } 19 | printf(" default:\n"); 20 | printf(" bufpush(c);\n"); 21 | print(" }\n"); 22 | 23 | -------------------------------------------------------------------------------- /bench/samples/inline-autolink.md: -------------------------------------------------------------------------------- 1 | closed (valid) autolinks: 2 | 3 | <ftp://1.2.3.4:21/path/foo> 4 | <http://foo.bar.baz?q=hello&id=22&boolean> 5 | <http://veeeeeeeeeeeeeeeeeeery.loooooooooooooooooooooooooooooooong.autolink/> 6 | <teeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeest@gmail.com> 7 | 8 | these are not autolinks: 9 | 10 | <ftp://1.2.3.4:21/path/foo 11 | <http://foo.bar.baz?q=hello&id=22&boolean 12 | <http://veeeeeeeeeeeeeeeeeeery.loooooooooooooooooooooooooooooooong.autolink 13 | <teeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeest@gmail.com 14 | < http://foo.bar.baz?q=hello&id=22&boolean > 15 | -------------------------------------------------------------------------------- /src/plugin.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_PLUGIN_H 2 | #define CMARK_PLUGIN_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #include "cmark-gfm.h" 9 | #include "cmark-gfm-extension_api.h" 10 | 11 | /** 12 | * cmark_plugin: 13 | * 14 | * A plugin structure, which should be filled by plugin's 15 | * init functions. 16 | */ 17 | struct cmark_plugin { 18 | cmark_llist *syntax_extensions; 19 | }; 20 | 21 | cmark_llist * 22 | cmark_plugin_steal_syntax_extensions(cmark_plugin *plugin); 23 | 24 | cmark_plugin * 25 | cmark_plugin_new(void); 26 | 27 | void 28 | cmark_plugin_free(cmark_plugin *plugin); 29 | 30 | #ifdef __cplusplus 31 | } 32 | #endif 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/cmark_ctype.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_CMARK_CTYPE_H 2 | #define CMARK_CMARK_CTYPE_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #include "cmark-gfm_export.h" 9 | 10 | /** Locale-independent versions of functions from ctype.h. 11 | * We want cmark to behave the same no matter what the system locale. 12 | */ 13 | 14 | CMARK_GFM_EXPORT 15 | int cmark_isspace(char c); 16 | 17 | CMARK_GFM_EXPORT 18 | int cmark_ispunct(char c); 19 | 20 | CMARK_GFM_EXPORT 21 | int cmark_isalnum(char c); 22 | 23 | CMARK_GFM_EXPORT 24 | int cmark_isdigit(char c); 25 | 26 | CMARK_GFM_EXPORT 27 | int cmark_isalpha(char c); 28 | 29 | #ifdef __cplusplus 30 | } 31 | #endif 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /fuzz/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include_directories( 2 | ${PROJECT_BINARY_DIR}/extensions 3 | ${PROJECT_BINARY_DIR}/src 4 | ../extensions 5 | ../src 6 | ) 7 | 8 | macro(fuzzer name) 9 | add_executable(${name} ${name}.c) 10 | set_target_properties(${name} 11 | PROPERTIES 12 | COMPILE_FLAGS "-fsanitize=fuzzer" 13 | LINK_FLAGS "-fsanitize=fuzzer") 14 | if(CMARK_SHARED) 15 | target_link_libraries(${name} libcmark-gfm-extensions libcmark-gfm) 16 | elseif(CMARK_STATIC) 17 | target_link_libraries(${name} libcmark-gfm-extensions_static libcmark-gfm_static) 18 | endif() 19 | endmacro() 20 | 21 | fuzzer(fuzz_quadratic) 22 | fuzzer(fuzz_quadratic_brackets) 23 | -------------------------------------------------------------------------------- /bench/samples/inline-html.md: -------------------------------------------------------------------------------- 1 | Taking commonmark tests from the spec for benchmarking here: 2 | 3 | <a><bab><c2c> 4 | 5 | <a/><b2/> 6 | 7 | <a /><b2 8 | data="foo" > 9 | 10 | <a foo="bar" bam = 'baz <em>"</em>' 11 | _boolean zoop:33=zoop:33 /> 12 | 13 | <33> <__> 14 | 15 | <a h*#ref="hi"> 16 | 17 | <a href="hi'> <a href=hi'> 18 | 19 | < a>< 20 | foo><bar/ > 21 | 22 | <a href='bar'title=title> 23 | 24 | </a> 25 | </foo > 26 | 27 | </a href="foo"> 28 | 29 | foo <!-- this is a 30 | comment - with hyphen --> 31 | 32 | foo <!-- not a comment -- two hyphens --> 33 | 34 | foo <?php echo $a; ?> 35 | 36 | foo <!ELEMENT br EMPTY> 37 | 38 | foo <![CDATA[>&<]]> 39 | 40 | <a href="&ouml;"> 41 | 42 | <a href="\*"> 43 | 44 | <a href="\""> 45 | -------------------------------------------------------------------------------- /toolchain-mingw32.cmake: -------------------------------------------------------------------------------- 1 | # the name of the target operating system 2 | SET(CMAKE_SYSTEM_NAME Windows) 3 | 4 | # which compilers to use for C and C++ 5 | SET(CMAKE_C_COMPILER i586-mingw32msvc-gcc) 6 | SET(CMAKE_CXX_COMPILER i586-mingw32msvc-g++) 7 | SET(CMAKE_RC_COMPILER i586-mingw32msvc-windres) 8 | 9 | # here is the target environment located 10 | SET(CMAKE_FIND_ROOT_PATH /usr/i586-mingw32msvc "${CMAKE_SOURCE_DIR}/windows") 11 | 12 | # adjust the default behaviour of the FIND_XYZ() commands: 13 | # search headers and libraries in the target environment, search 14 | # programs in the host environment 15 | set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) 16 | set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) 17 | set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) 18 | -------------------------------------------------------------------------------- /src/html.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_HTML_H 2 | #define CMARK_HTML_H 3 | 4 | #include "buffer.h" 5 | #include "node.h" 6 | 7 | CMARK_INLINE 8 | static void cmark_html_render_cr(cmark_strbuf *html) { 9 | if (html->size && html->ptr[html->size - 1] != '\n') 10 | cmark_strbuf_putc(html, '\n'); 11 | } 12 | 13 | #define BUFFER_SIZE 100 14 | 15 | CMARK_INLINE 16 | static void cmark_html_render_sourcepos(cmark_node *node, cmark_strbuf *html, int options) { 17 | char buffer[BUFFER_SIZE]; 18 | if (CMARK_OPT_SOURCEPOS & options) { 19 | snprintf(buffer, BUFFER_SIZE, " data-sourcepos=\"%d:%d-%d:%d\"", 20 | cmark_node_get_start_line(node), cmark_node_get_start_column(node), 21 | cmark_node_get_end_line(node), cmark_node_get_end_column(node)); 22 | cmark_strbuf_puts(html, buffer); 23 | } 24 | } 25 | 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /bench/samples/inline-links-flat.md: -------------------------------------------------------------------------------- 1 | Valid links: 2 | 3 | [this is a link]() 4 | [this is a link](<http://something.example.com/foo/bar>) 5 | [this is a link](http://something.example.com/foo/bar 'test') 6 | ![this is an image]() 7 | ![this is an image](<http://something.example.com/foo/bar>) 8 | ![this is an image](http://something.example.com/foo/bar 'test') 9 | 10 | [escape test](<\>\>\>\>\>\>\>\>\>\>\>\>\>\>> '\'\'\'\'\'\'\'\'\'\'\'\'\'\'') 11 | [escape test \]\]\]\]\]\]\]\]\]\]\]\]\]\]\]\]](\)\)\)\)\)\)\)\)\)\)\)\)\)\)) 12 | 13 | Invalid links: 14 | 15 | [this is not a link 16 | 17 | [this is not a link]( 18 | 19 | [this is not a link](http://something.example.com/foo/bar 'test' 20 | 21 | [this is not a link]((((((((((((((((((((((((((((((((((((((((((((((( 22 | 23 | [this is not a link]((((((((((()))))))))) (((((((((())))))))))) 24 | -------------------------------------------------------------------------------- /bench/samples/block-list-flat.md: -------------------------------------------------------------------------------- 1 | - tidy 2 | - bullet 3 | - list 4 | 5 | 6 | - loose 7 | 8 | - bullet 9 | 10 | - list 11 | 12 | 13 | 0. ordered 14 | 1. list 15 | 2. example 16 | 17 | 18 | - 19 | - 20 | - 21 | - 22 | 23 | 24 | 1. 25 | 2. 26 | 3. 27 | 28 | 29 | - an example 30 | of a list item 31 | with a continuation 32 | 33 | this part is inside the list 34 | 35 | this part is just a paragraph 36 | 37 | 38 | 1. test 39 | - test 40 | 1. test 41 | - test 42 | 43 | 44 | 111111111111111111111111111111111111111111. is this a valid bullet? 45 | 46 | - _________________________ 47 | 48 | - this 49 | - is 50 | 51 | a 52 | 53 | long 54 | - loose 55 | - list 56 | 57 | - with 58 | - some 59 | 60 | tidy 61 | 62 | - list 63 | - items 64 | - in 65 | 66 | - between 67 | - _________________________ 68 | -------------------------------------------------------------------------------- /fuzz/fuzzloop.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Stop when an error is found 4 | set -e 5 | 6 | # Create a corpus sub-directory if it doesn't already exist. 7 | mkdir -p corpus 8 | 9 | # The memory and disk usage grows over time, so this loop restarts the 10 | # fuzzer every 4 hours. The `-merge=1` option is used to minimize the 11 | # corpus on each iteration. 12 | while : 13 | do 14 | date 15 | echo restarting loop 16 | 17 | # Minimize the corpus 18 | mv corpus/ corpus2 19 | mkdir corpus 20 | echo minimizing corpus 21 | ./fuzz/fuzz_quadratic -merge=1 corpus ../bench corpus2/ -max_len=1024 22 | rm -r corpus2 23 | 24 | # Run the fuzzer for 4 hours 25 | date 26 | echo start fuzzer 27 | ./fuzz/fuzz_quadratic corpus -dict=../test/fuzzing_dictionary -jobs=$(nproc) -workers=$(nproc) -max_len=1024 -max_total_time=14400 28 | done 29 | -------------------------------------------------------------------------------- /src/utf8.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_UTF8_H 2 | #define CMARK_UTF8_H 3 | 4 | #include <stdint.h> 5 | #include "buffer.h" 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | CMARK_GFM_EXPORT 12 | void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, 13 | bufsize_t len); 14 | 15 | CMARK_GFM_EXPORT 16 | void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf); 17 | 18 | CMARK_GFM_EXPORT 19 | int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst); 20 | 21 | CMARK_GFM_EXPORT 22 | void cmark_utf8proc_check(cmark_strbuf *dest, const uint8_t *line, 23 | bufsize_t size); 24 | 25 | CMARK_GFM_EXPORT 26 | int cmark_utf8proc_is_space(int32_t uc); 27 | 28 | CMARK_GFM_EXPORT 29 | int cmark_utf8proc_is_punctuation(int32_t uc); 30 | 31 | #ifdef __cplusplus 32 | } 33 | #endif 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /api_test/harness.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_API_TEST_HARNESS_H 2 | #define CMARK_API_TEST_HARNESS_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | typedef struct { 9 | int test_num; 10 | int num_passed; 11 | int num_failed; 12 | int num_skipped; 13 | } test_batch_runner; 14 | 15 | test_batch_runner *test_batch_runner_new(); 16 | 17 | void SKIP(test_batch_runner *runner, int num_tests); 18 | 19 | void OK(test_batch_runner *runner, int cond, const char *msg, ...); 20 | 21 | void INT_EQ(test_batch_runner *runner, int got, int expected, const char *msg, 22 | ...); 23 | 24 | void STR_EQ(test_batch_runner *runner, const char *got, const char *expected, 25 | const char *msg, ...); 26 | 27 | int test_ok(test_batch_runner *runner); 28 | 29 | void test_print_summary(test_batch_runner *runner); 30 | 31 | #ifdef __cplusplus 32 | } 33 | #endif 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /src/inlines.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_INLINES_H 2 | #define CMARK_INLINES_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #include "references.h" 9 | 10 | cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url); 11 | cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title); 12 | 13 | CMARK_GFM_EXPORT 14 | void cmark_parse_inlines(cmark_parser *parser, 15 | cmark_node *parent, 16 | cmark_map *refmap, 17 | int options); 18 | 19 | bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input, 20 | cmark_map *refmap); 21 | 22 | void cmark_inlines_add_special_character(unsigned char c, bool emphasis); 23 | void cmark_inlines_remove_special_character(unsigned char c, bool emphasis); 24 | 25 | #ifdef __cplusplus 26 | } 27 | #endif 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /src/linked_list.c: -------------------------------------------------------------------------------- 1 | #include <stdlib.h> 2 | 3 | #include "cmark-gfm.h" 4 | 5 | cmark_llist *cmark_llist_append(cmark_mem *mem, cmark_llist *head, void *data) { 6 | cmark_llist *tmp; 7 | cmark_llist *new_node = (cmark_llist *) mem->calloc(1, sizeof(cmark_llist)); 8 | 9 | new_node->data = data; 10 | new_node->next = NULL; 11 | 12 | if (!head) 13 | return new_node; 14 | 15 | for (tmp = head; tmp->next; tmp=tmp->next); 16 | 17 | tmp->next = new_node; 18 | 19 | return head; 20 | } 21 | 22 | void cmark_llist_free_full(cmark_mem *mem, cmark_llist *head, cmark_free_func free_func) { 23 | cmark_llist *tmp, *prev; 24 | 25 | for (tmp = head; tmp;) { 26 | if (free_func) 27 | free_func(mem, tmp->data); 28 | 29 | prev = tmp; 30 | tmp = tmp->next; 31 | mem->free(prev); 32 | } 33 | } 34 | 35 | void cmark_llist_free(cmark_mem *mem, cmark_llist *head) { 36 | cmark_llist_free_full(mem, head, NULL); 37 | } 38 | -------------------------------------------------------------------------------- /test/extensions-table-prefer-style-attributes.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Extensions test with --table-prefer-style-attributes 3 | author: FUJI Goro 4 | version: 0.1 5 | date: '2018-02-20' 6 | license: '[CC-BY-SA 4.0](http://creativecommons.org/licenses/by-sa/4.0/)' 7 | ... 8 | 9 | ## Tables 10 | 11 | Table alignment: 12 | 13 | ```````````````````````````````` example 14 | aaa | bbb | ccc | ddd | eee 15 | :-- | --- | :-: | --- | --: 16 | fff | ggg | hhh | iii | jjj 17 | . 18 | <table> 19 | <thead> 20 | <tr> 21 | <th style="text-align: left">aaa</th> 22 | <th>bbb</th> 23 | <th style="text-align: center">ccc</th> 24 | <th>ddd</th> 25 | <th style="text-align: right">eee</th> 26 | </tr> 27 | </thead> 28 | <tbody> 29 | <tr> 30 | <td style="text-align: left">fff</td> 31 | <td>ggg</td> 32 | <td style="text-align: center">hhh</td> 33 | <td>iii</td> 34 | <td style="text-align: right">jjj</td> 35 | </tr> 36 | </tbody> 37 | </table> 38 | ```````````````````````````````` 39 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | # Ensures that sudo is disabled, so that containerized builds are allowed 2 | sudo: false 3 | 4 | os: 5 | - linux 6 | - osx 7 | language: c 8 | compiler: 9 | - clang 10 | - gcc 11 | matrix: 12 | include: 13 | - os: linux 14 | compiler: gcc 15 | env: CMAKE_OPTIONS="-DCMARK_SHARED=OFF" 16 | addons: 17 | apt: 18 | # we need a more recent cmake than travis/linux provides (at least 2.8.9): 19 | sources: 20 | - kubuntu-backports 21 | - kalakris-cmake 22 | packages: 23 | - cmake 24 | - python3 25 | - valgrind 26 | before_install: 27 | - | 28 | if [ ${TRAVIS_OS_NAME:-'linux'} = 'osx' ] 29 | then 30 | echo "Building without python3, to make sure that works." 31 | fi 32 | 33 | script: 34 | - (mkdir -p build && cd build && cmake $CMAKE_OPTIONS ..) 35 | - make test 36 | - | 37 | if [ ${TRAVIS_OS_NAME:-'linux'} = 'linux' ] 38 | then 39 | make leakcheck 40 | fi 41 | -------------------------------------------------------------------------------- /tools/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM debian:jessie 2 | 3 | RUN apt-get update && apt-get install -y \ 4 | build-essential \ 5 | autoconf \ 6 | libtool \ 7 | git \ 8 | pkg-config \ 9 | gdb \ 10 | valgrind \ 11 | python3 \ 12 | wget \ 13 | clang \ 14 | man \ 15 | clang-format \ 16 | && apt-get clean 17 | 18 | RUN wget http://lcamtuf.coredump.cx/afl/releases/afl-latest.tgz && \ 19 | tar xf afl-latest.tgz && \ 20 | cd afl-* && \ 21 | make install && \ 22 | cd .. && \ 23 | rm -rf afl-* 24 | 25 | RUN wget https://github.com/skvadrik/re2c/releases/download/0.15.3/re2c-0.15.3.tar.gz && \ 26 | tar xf re2c-0.15.3.tar.gz && \ 27 | cd re2c-* && \ 28 | ./configure && \ 29 | make install && \ 30 | cd .. && \ 31 | rm -rf re2c-* 32 | 33 | RUN wget https://cmake.org/files/v3.8/cmake-3.8.2.tar.gz && \ 34 | tar xf cmake-3.8.2.tar.gz && \ 35 | cd cmake-* && \ 36 | ./bootstrap && \ 37 | make install && \ 38 | cd .. && \ 39 | rm -rf cmake-* 40 | 41 | RUN apt-get update && apt-get install -y ninja-build 42 | -------------------------------------------------------------------------------- /extensions/ext_scanners.h: -------------------------------------------------------------------------------- 1 | #include "chunk.h" 2 | #include "cmark-gfm.h" 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | bufsize_t _ext_scan_at(bufsize_t (*scanner)(const unsigned char *), 9 | unsigned char *ptr, int len, bufsize_t offset); 10 | bufsize_t _scan_table_start(const unsigned char *p); 11 | bufsize_t _scan_table_cell(const unsigned char *p); 12 | bufsize_t _scan_table_cell_end(const unsigned char *p); 13 | bufsize_t _scan_table_row_end(const unsigned char *p); 14 | bufsize_t _scan_tasklist(const unsigned char *p); 15 | 16 | #define scan_table_start(c, l, n) _ext_scan_at(&_scan_table_start, c, l, n) 17 | #define scan_table_cell(c, l, n) _ext_scan_at(&_scan_table_cell, c, l, n) 18 | #define scan_table_cell_end(c, l, n) _ext_scan_at(&_scan_table_cell_end, c, l, n) 19 | #define scan_table_row_end(c, l, n) _ext_scan_at(&_scan_table_row_end, c, l, n) 20 | #define scan_tasklist(c, l, n) _ext_scan_at(&_scan_tasklist, c, l, n) 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | -------------------------------------------------------------------------------- /extensions/core-extensions.c: -------------------------------------------------------------------------------- 1 | #include "cmark-gfm-core-extensions.h" 2 | #include "autolink.h" 3 | #include "strikethrough.h" 4 | #include "table.h" 5 | #include "tagfilter.h" 6 | #include "tasklist.h" 7 | #include "registry.h" 8 | #include "plugin.h" 9 | 10 | static int core_extensions_registration(cmark_plugin *plugin) { 11 | cmark_plugin_register_syntax_extension(plugin, create_table_extension()); 12 | cmark_plugin_register_syntax_extension(plugin, 13 | create_strikethrough_extension()); 14 | cmark_plugin_register_syntax_extension(plugin, create_autolink_extension()); 15 | cmark_plugin_register_syntax_extension(plugin, create_tagfilter_extension()); 16 | cmark_plugin_register_syntax_extension(plugin, create_tasklist_extension()); 17 | return 1; 18 | } 19 | 20 | void cmark_gfm_core_extensions_ensure_registered(void) { 21 | static int registered = 0; 22 | 23 | if (!registered) { 24 | cmark_register_plugin(core_extensions_registration); 25 | registered = 1; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /api_test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(api_test 2 | cplusplus.cpp 3 | harness.c 4 | harness.h 5 | main.c 6 | ) 7 | include_directories( 8 | ${PROJECT_SOURCE_DIR}/src 9 | ${PROJECT_BINARY_DIR}/src 10 | ${PROJECT_BINARY_DIR}/extensions 11 | ) 12 | if(CMARK_SHARED) 13 | target_link_libraries(api_test libcmark-gfm-extensions libcmark-gfm) 14 | else() 15 | target_link_libraries(api_test libcmark-gfm-extensions_static libcmark-gfm_static) 16 | endif() 17 | 18 | # Compiler flags 19 | if(MSVC) 20 | # Force to always compile with W4 21 | if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") 22 | string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") 23 | else() 24 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4") 25 | endif() 26 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4706 /D_CRT_SECURE_NO_WARNINGS") 27 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /TP") 28 | elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") 29 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=c99 -pedantic") 30 | endif() 31 | -------------------------------------------------------------------------------- /src/map.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_MAP_H 2 | #define CMARK_MAP_H 3 | 4 | #include "chunk.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | struct cmark_map_entry { 11 | struct cmark_map_entry *next; 12 | unsigned char *label; 13 | size_t age; 14 | size_t size; 15 | }; 16 | 17 | typedef struct cmark_map_entry cmark_map_entry; 18 | 19 | struct cmark_map; 20 | 21 | typedef void (*cmark_map_free_f)(struct cmark_map *, cmark_map_entry *); 22 | 23 | struct cmark_map { 24 | cmark_mem *mem; 25 | cmark_map_entry *refs; 26 | cmark_map_entry **sorted; 27 | size_t size; 28 | size_t ref_size; 29 | size_t max_ref_size; 30 | cmark_map_free_f free; 31 | }; 32 | 33 | typedef struct cmark_map cmark_map; 34 | 35 | unsigned char *normalize_map_label(cmark_mem *mem, cmark_chunk *ref); 36 | cmark_map *cmark_map_new(cmark_mem *mem, cmark_map_free_f free); 37 | void cmark_map_free(cmark_map *map); 38 | cmark_map_entry *cmark_map_lookup(cmark_map *map, cmark_chunk *label); 39 | 40 | #ifdef __cplusplus 41 | } 42 | #endif 43 | 44 | #endif 45 | -------------------------------------------------------------------------------- /Makefile.nmake: -------------------------------------------------------------------------------- 1 | SRCDIR=src 2 | DATADIR=data 3 | BUILDDIR=build 4 | INSTALLDIR=windows 5 | SPEC=test/spec.txt 6 | PROG=$(BUILDDIR)\src\cmark-gfm.exe 7 | GENERATOR=NMake Makefiles 8 | 9 | all: $(BUILDDIR)/CMakeFiles 10 | @cd $(BUILDDIR) && $(MAKE) /nologo && cd .. 11 | 12 | $(BUILDDIR)/CMakeFiles: 13 | @-mkdir $(BUILDDIR) 2> nul 14 | cd $(BUILDDIR) && \ 15 | cmake \ 16 | -G "$(GENERATOR)" \ 17 | -D CMAKE_BUILD_TYPE=$(BUILD_TYPE) \ 18 | -D CMAKE_INSTALL_PREFIX=$(INSTALLDIR) \ 19 | -D CMARK_STATIC=ON \ 20 | -D CMARK_SHARED=OFF \ 21 | .. && \ 22 | cd .. 23 | 24 | install: all 25 | @cd $(BUILDDIR) && $(MAKE) /nologo install && cd .. 26 | 27 | clean: 28 | -rmdir /s /q $(BUILDDIR) $(MINGW_INSTALLDIR) 2> nul 29 | 30 | $(SRCDIR)\case_fold_switch.inc: $(DATADIR)\CaseFolding-3.2.0.txt 31 | perl mkcasefold.pl < $? > $@ 32 | 33 | test: $(SPEC) all 34 | @cd $(BUILDDIR) && $(MAKE) /nologo test ARGS="-V" && cd .. 35 | 36 | distclean: clean 37 | del /q src\scanners.c 2> nul 38 | del /q spec.md spec.html 2> nul 39 | -------------------------------------------------------------------------------- /wrappers/wrapper.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | # Example for using the shared library from python 4 | # Will work with either python 2 or python 3 5 | # Requires cmark library to be installed 6 | 7 | from ctypes import CDLL, c_char_p, c_long 8 | import sys 9 | import platform 10 | 11 | sysname = platform.system() 12 | 13 | if sysname == 'Darwin': 14 | libname = "libcmark.dylib" 15 | elif sysname == 'Windows': 16 | libname = "cmark.dll" 17 | else: 18 | libname = "libcmark.so" 19 | cmark = CDLL(libname) 20 | 21 | markdown = cmark.cmark_markdown_to_html 22 | markdown.restype = c_char_p 23 | markdown.argtypes = [c_char_p, c_long, c_long] 24 | 25 | opts = 0 # defaults 26 | 27 | def md2html(text): 28 | if sys.version_info >= (3,0): 29 | textbytes = text.encode('utf-8') 30 | textlen = len(textbytes) 31 | return markdown(textbytes, textlen, opts).decode('utf-8') 32 | else: 33 | textbytes = text 34 | textlen = len(text) 35 | return markdown(textbytes, textlen, opts) 36 | 37 | sys.stdout.write(md2html(sys.stdin.read())) 38 | -------------------------------------------------------------------------------- /tools/make_entities_inc.py: -------------------------------------------------------------------------------- 1 | # Creates C data structures for binary lookup table of entities, 2 | # using python's html5 entity data. 3 | # Usage: python3 tools/make_entities_inc.py > src/entities.inc 4 | 5 | import html 6 | 7 | entities5 = html.entities.html5 8 | 9 | # remove keys without semicolons. For some reason the list 10 | # has duplicates of a few things, like auml, one with and one 11 | # without a semicolon. 12 | entities = sorted([(k[:-1], entities5[k].encode('utf-8')) for k in entities5.keys() if k[-1] == ';']) 13 | 14 | # Print out the header: 15 | print("""/* Autogenerated by tools/make_headers_inc.py */ 16 | 17 | struct cmark_entity_node { 18 | unsigned char *entity; 19 | unsigned char bytes[8]; 20 | }; 21 | 22 | #define CMARK_ENTITY_MIN_LENGTH 2 23 | #define CMARK_ENTITY_MAX_LENGTH 32""") 24 | 25 | print("#define CMARK_NUM_ENTITIES " + str(len(entities))); 26 | 27 | print("\nstatic const struct cmark_entity_node cmark_entities[] = {"); 28 | 29 | for (ent, bs) in entities: 30 | print('{(unsigned char*)"' + ent + '", {' + ', '.join(map(str, bs)) + ', 0}},') 31 | 32 | print("};") 33 | -------------------------------------------------------------------------------- /src/plugin.c: -------------------------------------------------------------------------------- 1 | #include <stdlib.h> 2 | 3 | #include "plugin.h" 4 | 5 | extern cmark_mem CMARK_DEFAULT_MEM_ALLOCATOR; 6 | 7 | int cmark_plugin_register_syntax_extension(cmark_plugin * plugin, 8 | cmark_syntax_extension * extension) { 9 | plugin->syntax_extensions = cmark_llist_append(&CMARK_DEFAULT_MEM_ALLOCATOR, plugin->syntax_extensions, extension); 10 | return 1; 11 | } 12 | 13 | cmark_plugin * 14 | cmark_plugin_new(void) { 15 | cmark_plugin *res = (cmark_plugin *) CMARK_DEFAULT_MEM_ALLOCATOR.calloc(1, sizeof(cmark_plugin)); 16 | 17 | res->syntax_extensions = NULL; 18 | 19 | return res; 20 | } 21 | 22 | void 23 | cmark_plugin_free(cmark_plugin *plugin) { 24 | cmark_llist_free_full(&CMARK_DEFAULT_MEM_ALLOCATOR, 25 | plugin->syntax_extensions, 26 | (cmark_free_func) cmark_syntax_extension_free); 27 | CMARK_DEFAULT_MEM_ALLOCATOR.free(plugin); 28 | } 29 | 30 | cmark_llist * 31 | cmark_plugin_steal_syntax_extensions(cmark_plugin *plugin) { 32 | cmark_llist *res = plugin->syntax_extensions; 33 | 34 | plugin->syntax_extensions = NULL; 35 | return res; 36 | } 37 | -------------------------------------------------------------------------------- /benchmarks.md: -------------------------------------------------------------------------------- 1 | # Benchmarks 2 | 3 | Here are some benchmarks, run on an ancient Thinkpad running Intel 4 | Core 2 Duo at 2GHz. The input text is a 11MB Markdown file built by 5 | concatenating the Markdown sources of all the localizations of the 6 | first edition of 7 | [*Pro Git*](https://github.com/progit/progit/tree/master/en) by Scott 8 | Chacon. 9 | 10 | |Implementation | Time (sec)| 11 | |-------------------|-----------:| 12 | | Markdown.pl | 2921.24 | 13 | | Python markdown | 291.25 | 14 | | PHP markdown | 20.82 | 15 | | kramdown | 17.32 | 16 | | cheapskate | 8.24 | 17 | | peg-markdown | 5.45 | 18 | | parsedown | 5.06 | 19 | | **commonmark.js** | 2.09 | 20 | | marked | 1.99 | 21 | | discount | 1.85 | 22 | | **cmark** | 0.29 | 23 | | hoedown | 0.21 | 24 | 25 | To run these benchmarks, use `make bench PROG=/path/to/program`. 26 | 27 | `time` is used to measure execution speed. The reported 28 | time is the *difference* between the time to run the program 29 | with the benchmark input and the time to run it with no input. 30 | (This procedure ensures that implementations in dynamic languages are 31 | not penalized by startup time.) A median of ten runs is taken. The 32 | process is reniced to a high priority so that the system doesn't 33 | interrupt runs. 34 | -------------------------------------------------------------------------------- /src/references.c: -------------------------------------------------------------------------------- 1 | #include "cmark-gfm.h" 2 | #include "parser.h" 3 | #include "references.h" 4 | #include "inlines.h" 5 | #include "chunk.h" 6 | 7 | static void reference_free(cmark_map *map, cmark_map_entry *_ref) { 8 | cmark_reference *ref = (cmark_reference *)_ref; 9 | cmark_mem *mem = map->mem; 10 | if (ref != NULL) { 11 | mem->free(ref->entry.label); 12 | cmark_chunk_free(mem, &ref->url); 13 | cmark_chunk_free(mem, &ref->title); 14 | mem->free(ref); 15 | } 16 | } 17 | 18 | void cmark_reference_create(cmark_map *map, cmark_chunk *label, 19 | cmark_chunk *url, cmark_chunk *title) { 20 | cmark_reference *ref; 21 | unsigned char *reflabel = normalize_map_label(map->mem, label); 22 | 23 | /* empty reference name, or composed from only whitespace */ 24 | if (reflabel == NULL) 25 | return; 26 | 27 | assert(map->sorted == NULL); 28 | 29 | ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref)); 30 | ref->entry.label = reflabel; 31 | ref->url = cmark_clean_url(map->mem, url); 32 | ref->title = cmark_clean_title(map->mem, title); 33 | ref->entry.age = map->size; 34 | ref->entry.next = map->refs; 35 | ref->entry.size = ref->url.len + ref->title.len; 36 | 37 | map->refs = (cmark_map_entry *)ref; 38 | map->size++; 39 | } 40 | 41 | cmark_map *cmark_reference_map_new(cmark_mem *mem) { 42 | return cmark_map_new(mem, reference_free); 43 | } 44 | -------------------------------------------------------------------------------- /extensions/tagfilter.c: -------------------------------------------------------------------------------- 1 | #include "tagfilter.h" 2 | #include <parser.h> 3 | #include <ctype.h> 4 | 5 | static const char *blacklist[] = { 6 | "title", "textarea", "style", "xmp", "iframe", 7 | "noembed", "noframes", "script", "plaintext", NULL, 8 | }; 9 | 10 | static int is_tag(const unsigned char *tag_data, size_t tag_size, 11 | const char *tagname) { 12 | size_t i; 13 | 14 | if (tag_size < 3 || tag_data[0] != '<') 15 | return 0; 16 | 17 | i = 1; 18 | 19 | if (tag_data[i] == '/') { 20 | i++; 21 | } 22 | 23 | for (; i < tag_size; ++i, ++tagname) { 24 | if (*tagname == 0) 25 | break; 26 | 27 | if (tolower(tag_data[i]) != *tagname) 28 | return 0; 29 | } 30 | 31 | if (i == tag_size) 32 | return 0; 33 | 34 | if (cmark_isspace(tag_data[i]) || tag_data[i] == '>') 35 | return 1; 36 | 37 | if (tag_data[i] == '/' && tag_size >= i + 2 && tag_data[i + 1] == '>') 38 | return 1; 39 | 40 | return 0; 41 | } 42 | 43 | static int filter(cmark_syntax_extension *ext, const unsigned char *tag, 44 | size_t tag_len) { 45 | const char **it; 46 | 47 | for (it = blacklist; *it; ++it) { 48 | if (is_tag(tag, tag_len, *it)) { 49 | return 0; 50 | } 51 | } 52 | 53 | return 1; 54 | } 55 | 56 | cmark_syntax_extension *create_tagfilter_extension(void) { 57 | cmark_syntax_extension *ext = cmark_syntax_extension_new("tagfilter"); 58 | cmark_syntax_extension_set_html_filter_func(ext, filter); 59 | return ext; 60 | } 61 | -------------------------------------------------------------------------------- /src/syntax_extension.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_SYNTAX_EXTENSION_H 2 | #define CMARK_SYNTAX_EXTENSION_H 3 | 4 | #include "cmark-gfm.h" 5 | #include "cmark-gfm-extension_api.h" 6 | #include "config.h" 7 | 8 | struct cmark_syntax_extension { 9 | cmark_match_block_func last_block_matches; 10 | cmark_open_block_func try_opening_block; 11 | cmark_match_inline_func match_inline; 12 | cmark_inline_from_delim_func insert_inline_from_delim; 13 | cmark_llist * special_inline_chars; 14 | char * name; 15 | void * priv; 16 | bool emphasis; 17 | cmark_free_func free_function; 18 | cmark_get_type_string_func get_type_string_func; 19 | cmark_can_contain_func can_contain_func; 20 | cmark_contains_inlines_func contains_inlines_func; 21 | cmark_common_render_func commonmark_render_func; 22 | cmark_common_render_func plaintext_render_func; 23 | cmark_common_render_func latex_render_func; 24 | cmark_xml_attr_func xml_attr_func; 25 | cmark_common_render_func man_render_func; 26 | cmark_html_render_func html_render_func; 27 | cmark_html_filter_func html_filter_func; 28 | cmark_postprocess_func postprocess_func; 29 | cmark_opaque_alloc_func opaque_alloc_func; 30 | cmark_opaque_free_func opaque_free_func; 31 | cmark_commonmark_escape_func commonmark_escape_func; 32 | }; 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/cmark.c: -------------------------------------------------------------------------------- 1 | #include <stdlib.h> 2 | #include <assert.h> 3 | #include <stdio.h> 4 | #include "registry.h" 5 | #include "node.h" 6 | #include "houdini.h" 7 | #include "cmark-gfm.h" 8 | #include "buffer.h" 9 | 10 | cmark_node_type CMARK_NODE_LAST_BLOCK = CMARK_NODE_FOOTNOTE_DEFINITION; 11 | cmark_node_type CMARK_NODE_LAST_INLINE = CMARK_NODE_FOOTNOTE_REFERENCE; 12 | 13 | int cmark_version(void) { return CMARK_GFM_VERSION; } 14 | 15 | const char *cmark_version_string(void) { return CMARK_GFM_VERSION_STRING; } 16 | 17 | static void *xcalloc(size_t nmem, size_t size) { 18 | void *ptr = calloc(nmem, size); 19 | if (!ptr) { 20 | fprintf(stderr, "[cmark] calloc returned null pointer, aborting\n"); 21 | abort(); 22 | } 23 | return ptr; 24 | } 25 | 26 | static void *xrealloc(void *ptr, size_t size) { 27 | void *new_ptr = realloc(ptr, size); 28 | if (!new_ptr) { 29 | fprintf(stderr, "[cmark] realloc returned null pointer, aborting\n"); 30 | abort(); 31 | } 32 | return new_ptr; 33 | } 34 | 35 | static void xfree(void *ptr) { 36 | free(ptr); 37 | } 38 | 39 | cmark_mem CMARK_DEFAULT_MEM_ALLOCATOR = {xcalloc, xrealloc, xfree}; 40 | 41 | cmark_mem *cmark_get_default_mem_allocator(void) { 42 | return &CMARK_DEFAULT_MEM_ALLOCATOR; 43 | } 44 | 45 | char *cmark_markdown_to_html(const char *text, size_t len, int options) { 46 | cmark_node *doc; 47 | char *result; 48 | 49 | doc = cmark_parse_document(text, len, options); 50 | 51 | result = cmark_render_html(doc, options, NULL); 52 | cmark_node_free(doc); 53 | 54 | return result; 55 | } 56 | -------------------------------------------------------------------------------- /test/fuzzing_dictionary: -------------------------------------------------------------------------------- 1 | asterisk="*" 2 | attr_generic=" a=\"1\"" 3 | attr_href=" href=\"1\"" 4 | attr_xml_lang=" xml:lang=\"1\"" 5 | attr_xmlns=" xmlns=\"1\"" 6 | backslash="\\" 7 | backtick="`" 8 | colon=":" 9 | dashes="---" 10 | double_quote="\"" 11 | entity_builtin="&lt;" 12 | entity_decimal="&#1;" 13 | entity_external="&a;" 14 | entity_hex="&#x1;" 15 | equals="===" 16 | exclamation="!" 17 | greater_than=">" 18 | hash="#" 19 | hyphen="-" 20 | indent=" " 21 | left_bracket="[" 22 | left_paren="(" 23 | less_than="<" 24 | plus="+" 25 | right_bracket="]" 26 | right_paren=")" 27 | single_quote="'" 28 | string_any="ANY" 29 | string_brackets="[]" 30 | string_cdata="CDATA" 31 | string_dashes="--" 32 | string_empty_dblquotes="\"\"" 33 | string_empty_quotes="''" 34 | string_idrefs="IDREFS" 35 | string_parentheses="()" 36 | string_pcdata="#PCDATA" 37 | tag_cdata="<![CDATA[" 38 | tag_close="</a>" 39 | tag_doctype="<!DOCTYPE" 40 | tag_element="<!ELEMENT" 41 | tag_entity="<!ENTITY" 42 | tag_notation="<!NOTATION" 43 | tag_open="<a>" 44 | tag_open_close="<a />" 45 | tag_open_exclamation="<!" 46 | tag_open_q="<?" 47 | tag_sq2_close="]]>" 48 | tag_xml_q="<?xml?>" 49 | underscore="_" 50 | 51 | # GFM specific 52 | 53 | strikethrough="~~~strike~~~" 54 | user_mention="@octocat" 55 | email_mention="octocat@github.com" 56 | http="http://" 57 | https="https://" 58 | ftp="ftp://" 59 | title_tag="title" 60 | textarea_tag="textarea" 61 | style_tag="style" 62 | xmp_tag="xmp" 63 | iframe_tag="iframe" 64 | noembed_tag="noembed" 65 | noframes_tag="noframes" 66 | script_tag="script" 67 | plaintext_tag="plaintext" 68 | -------------------------------------------------------------------------------- /src/config.h.in: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_CONFIG_H 2 | #define CMARK_CONFIG_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #cmakedefine HAVE_STDBOOL_H 9 | 10 | #ifdef HAVE_STDBOOL_H 11 | #include <stdbool.h> 12 | #elif !defined(__cplusplus) 13 | typedef char bool; 14 | #endif 15 | 16 | #cmakedefine HAVE___BUILTIN_EXPECT 17 | 18 | #cmakedefine HAVE___ATTRIBUTE__ 19 | 20 | #ifdef HAVE___ATTRIBUTE__ 21 | #define CMARK_ATTRIBUTE(list) __attribute__ (list) 22 | #else 23 | #define CMARK_ATTRIBUTE(list) 24 | #endif 25 | 26 | #ifndef CMARK_INLINE 27 | #if defined(_MSC_VER) && !defined(__cplusplus) 28 | #define CMARK_INLINE __inline 29 | #else 30 | #define CMARK_INLINE inline 31 | #endif 32 | #endif 33 | 34 | /* snprintf and vsnprintf fallbacks for MSVC before 2015, 35 | due to Valentin Milea http://stackoverflow.com/questions/2915672/ 36 | */ 37 | 38 | #if defined(_MSC_VER) && _MSC_VER < 1900 39 | 40 | #include <stdio.h> 41 | #include <stdarg.h> 42 | 43 | #define snprintf c99_snprintf 44 | #define vsnprintf c99_vsnprintf 45 | 46 | CMARK_INLINE int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap) 47 | { 48 | int count = -1; 49 | 50 | if (size != 0) 51 | count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap); 52 | if (count == -1) 53 | count = _vscprintf(format, ap); 54 | 55 | return count; 56 | } 57 | 58 | CMARK_INLINE int c99_snprintf(char *outBuf, size_t size, const char *format, ...) 59 | { 60 | int count; 61 | va_list ap; 62 | 63 | va_start(ap, format); 64 | count = c99_vsnprintf(outBuf, size, format, ap); 65 | va_end(ap); 66 | 67 | return count; 68 | } 69 | 70 | #endif 71 | 72 | #ifdef __cplusplus 73 | } 74 | #endif 75 | 76 | #endif 77 | -------------------------------------------------------------------------------- /test/extensions-full-info-string.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: --full-info-string test 3 | author: Ashe Connor 4 | version: 0.1 5 | date: '2018-08-08' 6 | license: '[CC-BY-SA 4.0](http://creativecommons.org/licenses/by-sa/4.0/)' 7 | ... 8 | 9 | ## `--full-info-string` 10 | 11 | Without extended info: 12 | 13 | ```````````````````````````````` example 14 | ```ruby 15 | module Foo 16 | ``` 17 | . 18 | <pre><code class="language-ruby">module Foo 19 | </code></pre> 20 | ```````````````````````````````` 21 | 22 | With extended info: 23 | 24 | ```````````````````````````````` example 25 | ```ruby some <extra> "data" 26 | module Foo 27 | ``` 28 | . 29 | <pre><code class="language-ruby" data-meta="some &lt;extra&gt; &quot;data&quot;">module Foo 30 | </code></pre> 31 | ```````````````````````````````` 32 | 33 | With an embedded NUL: 34 | 35 | ```````````````````````````````` example 36 | ```ruby nul�nul 37 | module Foo 38 | ``` 39 | . 40 | <pre><code class="language-ruby" data-meta="nul�nul">module Foo 41 | </code></pre> 42 | ```````````````````````````````` 43 | 44 | With a lot: 45 | 46 | ```````````````````````````````` example 47 | ```ruby xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 48 | module Foo 49 | ``` 50 | . 51 | <pre><code class="language-ruby" data-meta="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx">module Foo 52 | </code></pre> 53 | ```````````````````````````````` 54 | -------------------------------------------------------------------------------- /src/houdini.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_HOUDINI_H 2 | #define CMARK_HOUDINI_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #include <stdint.h> 9 | #include "config.h" 10 | #include "buffer.h" 11 | 12 | #ifdef HAVE___BUILTIN_EXPECT 13 | #define likely(x) __builtin_expect((x), 1) 14 | #define unlikely(x) __builtin_expect((x), 0) 15 | #else 16 | #define likely(x) (x) 17 | #define unlikely(x) (x) 18 | #endif 19 | 20 | #ifdef HOUDINI_USE_LOCALE 21 | #define _isxdigit(c) isxdigit(c) 22 | #define _isdigit(c) isdigit(c) 23 | #else 24 | /* 25 | * Helper _isdigit methods -- do not trust the current locale 26 | * */ 27 | #define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL) 28 | #define _isdigit(c) ((c) >= '0' && (c) <= '9') 29 | #endif 30 | 31 | #define HOUDINI_ESCAPED_SIZE(x) (((x)*12) / 10) 32 | #define HOUDINI_UNESCAPED_SIZE(x) (x) 33 | 34 | CMARK_GFM_EXPORT 35 | bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, 36 | bufsize_t size); 37 | CMARK_GFM_EXPORT 38 | int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, 39 | bufsize_t size); 40 | CMARK_GFM_EXPORT 41 | int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, 42 | bufsize_t size, int secure); 43 | CMARK_GFM_EXPORT 44 | int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, 45 | bufsize_t size); 46 | CMARK_GFM_EXPORT 47 | void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, 48 | bufsize_t size); 49 | CMARK_GFM_EXPORT 50 | int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, 51 | bufsize_t size); 52 | 53 | #ifdef __cplusplus 54 | } 55 | #endif 56 | 57 | #endif 58 | -------------------------------------------------------------------------------- /extensions/cmark-gfm-core-extensions.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_GFM_CORE_EXTENSIONS_H 2 | #define CMARK_GFM_CORE_EXTENSIONS_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #include "cmark-gfm-extension_api.h" 9 | #include "cmark-gfm_export.h" 10 | #include <stdbool.h> 11 | #include <stdint.h> 12 | 13 | CMARK_GFM_EXPORT 14 | void cmark_gfm_core_extensions_ensure_registered(void); 15 | 16 | CMARK_GFM_EXPORT 17 | uint16_t cmark_gfm_extensions_get_table_columns(cmark_node *node); 18 | 19 | /** Sets the number of columns for the table, returning 1 on success and 0 on error. 20 | */ 21 | CMARK_GFM_EXPORT 22 | int cmark_gfm_extensions_set_table_columns(cmark_node *node, uint16_t n_columns); 23 | 24 | CMARK_GFM_EXPORT 25 | uint8_t *cmark_gfm_extensions_get_table_alignments(cmark_node *node); 26 | 27 | /** Sets the alignments for the table, returning 1 on success and 0 on error. 28 | */ 29 | CMARK_GFM_EXPORT 30 | int cmark_gfm_extensions_set_table_alignments(cmark_node *node, uint16_t ncols, uint8_t *alignments); 31 | 32 | CMARK_GFM_EXPORT 33 | int cmark_gfm_extensions_get_table_row_is_header(cmark_node *node); 34 | 35 | /** Sets whether the node is a table header row, returning 1 on success and 0 on error. 36 | */ 37 | CMARK_GFM_EXPORT 38 | int cmark_gfm_extensions_set_table_row_is_header(cmark_node *node, int is_header); 39 | 40 | CMARK_GFM_EXPORT 41 | bool cmark_gfm_extensions_get_tasklist_item_checked(cmark_node *node); 42 | /* For backwards compatibility */ 43 | #define cmark_gfm_extensions_tasklist_is_checked cmark_gfm_extensions_get_tasklist_item_checked 44 | 45 | /** Sets whether a tasklist item is "checked" (completed), returning 1 on success and 0 on error. 46 | */ 47 | CMARK_GFM_EXPORT 48 | int cmark_gfm_extensions_set_tasklist_item_checked(cmark_node *node, bool is_checked); 49 | 50 | #ifdef __cplusplus 51 | } 52 | #endif 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /src/registry.c: -------------------------------------------------------------------------------- 1 | #include <stdint.h> 2 | #include <stdlib.h> 3 | #include <string.h> 4 | 5 | #include "config.h" 6 | #include "cmark-gfm.h" 7 | #include "syntax_extension.h" 8 | #include "registry.h" 9 | #include "plugin.h" 10 | 11 | extern cmark_mem CMARK_DEFAULT_MEM_ALLOCATOR; 12 | 13 | static cmark_llist *syntax_extensions = NULL; 14 | 15 | void cmark_register_plugin(cmark_plugin_init_func reg_fn) { 16 | cmark_plugin *plugin = cmark_plugin_new(); 17 | 18 | if (!reg_fn(plugin)) { 19 | cmark_plugin_free(plugin); 20 | return; 21 | } 22 | 23 | cmark_llist *syntax_extensions_list = cmark_plugin_steal_syntax_extensions(plugin), 24 | *it; 25 | 26 | for (it = syntax_extensions_list; it; it = it->next) { 27 | syntax_extensions = cmark_llist_append(&CMARK_DEFAULT_MEM_ALLOCATOR, syntax_extensions, it->data); 28 | } 29 | 30 | cmark_llist_free(&CMARK_DEFAULT_MEM_ALLOCATOR, syntax_extensions_list); 31 | cmark_plugin_free(plugin); 32 | } 33 | 34 | void cmark_release_plugins(void) { 35 | if (syntax_extensions) { 36 | cmark_llist_free_full( 37 | &CMARK_DEFAULT_MEM_ALLOCATOR, 38 | syntax_extensions, 39 | (cmark_free_func) cmark_syntax_extension_free); 40 | syntax_extensions = NULL; 41 | } 42 | } 43 | 44 | cmark_llist *cmark_list_syntax_extensions(cmark_mem *mem) { 45 | cmark_llist *it; 46 | cmark_llist *res = NULL; 47 | 48 | for (it = syntax_extensions; it; it = it->next) { 49 | res = cmark_llist_append(mem, res, it->data); 50 | } 51 | return res; 52 | } 53 | 54 | cmark_syntax_extension *cmark_find_syntax_extension(const char *name) { 55 | cmark_llist *tmp; 56 | 57 | for (tmp = syntax_extensions; tmp; tmp = tmp->next) { 58 | cmark_syntax_extension *ext = (cmark_syntax_extension *) tmp->data; 59 | if (!strcmp(ext->name, name)) 60 | return ext; 61 | } 62 | return NULL; 63 | } 64 | -------------------------------------------------------------------------------- /src/cmark_ctype.c: -------------------------------------------------------------------------------- 1 | #include <stdint.h> 2 | 3 | #include "cmark_ctype.h" 4 | 5 | /** 1 = space, 2 = punct, 3 = digit, 4 = alpha, 0 = other 6 | */ 7 | static const uint8_t cmark_ctype_class[256] = { 8 | /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 9 | /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 10 | /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11 | /* 2 */ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 12 | /* 3 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 13 | /* 4 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 14 | /* 5 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 15 | /* 6 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 16 | /* 7 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0, 17 | /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18 | /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19 | /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20 | /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21 | /* c */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22 | /* d */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23 | /* e */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24 | /* f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 25 | 26 | /** 27 | * Returns 1 if c is a "whitespace" character as defined by the spec. 28 | */ 29 | int cmark_isspace(char c) { return cmark_ctype_class[(uint8_t)c] == 1; } 30 | 31 | /** 32 | * Returns 1 if c is an ascii punctuation character. 33 | */ 34 | int cmark_ispunct(char c) { return cmark_ctype_class[(uint8_t)c] == 2; } 35 | 36 | int cmark_isalnum(char c) { 37 | uint8_t result; 38 | result = cmark_ctype_class[(uint8_t)c]; 39 | return (result == 3 || result == 4); 40 | } 41 | 42 | int cmark_isdigit(char c) { return cmark_ctype_class[(uint8_t)c] == 3; } 43 | 44 | int cmark_isalpha(char c) { return cmark_ctype_class[(uint8_t)c] == 4; } 45 | -------------------------------------------------------------------------------- /src/render.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_RENDER_H 2 | #define CMARK_RENDER_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #include <stdlib.h> 9 | #include "buffer.h" 10 | #include "chunk.h" 11 | 12 | typedef enum { LITERAL, NORMAL, TITLE, URL } cmark_escaping; 13 | 14 | struct cmark_renderer { 15 | cmark_mem *mem; 16 | cmark_strbuf *buffer; 17 | cmark_strbuf *prefix; 18 | int column; 19 | int width; 20 | int need_cr; 21 | bufsize_t last_breakable; 22 | bool begin_line; 23 | bool begin_content; 24 | bool no_linebreaks; 25 | bool in_tight_list_item; 26 | void (*outc)(struct cmark_renderer *, cmark_node *, cmark_escaping, int32_t, unsigned char); 27 | void (*cr)(struct cmark_renderer *); 28 | void (*blankline)(struct cmark_renderer *); 29 | void (*out)(struct cmark_renderer *, cmark_node *, const char *, bool, cmark_escaping); 30 | unsigned int footnote_ix; 31 | }; 32 | 33 | typedef struct cmark_renderer cmark_renderer; 34 | 35 | struct cmark_html_renderer { 36 | cmark_strbuf *html; 37 | cmark_node *plain; 38 | cmark_llist *filter_extensions; 39 | unsigned int footnote_ix; 40 | unsigned int written_footnote_ix; 41 | void *opaque; 42 | }; 43 | 44 | typedef struct cmark_html_renderer cmark_html_renderer; 45 | 46 | void cmark_render_ascii(cmark_renderer *renderer, const char *s); 47 | 48 | void cmark_render_code_point(cmark_renderer *renderer, uint32_t c); 49 | 50 | char *cmark_render(cmark_mem *mem, cmark_node *root, int options, int width, 51 | void (*outc)(cmark_renderer *, cmark_node *, 52 | cmark_escaping, int32_t, 53 | unsigned char), 54 | int (*render_node)(cmark_renderer *renderer, 55 | cmark_node *node, 56 | cmark_event_type ev_type, int options)); 57 | 58 | #ifdef __cplusplus 59 | } 60 | #endif 61 | 62 | #endif 63 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.0) 2 | project(cmark-gfm) 3 | 4 | set(PROJECT_VERSION_MAJOR 0) 5 | set(PROJECT_VERSION_MINOR 29) 6 | set(PROJECT_VERSION_PATCH 0) 7 | set(PROJECT_VERSION_GFM 13) 8 | set(PROJECT_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}.gfm.${PROJECT_VERSION_GFM}) 9 | 10 | include("FindAsan.cmake") 11 | include("CheckFileOffsetBits.cmake") 12 | 13 | if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}") 14 | message(FATAL_ERROR "Do not build in-source.\nPlease remove CMakeCache.txt and the CMakeFiles/ directory.\nThen: mkdir build ; cd build ; cmake .. ; make") 15 | endif() 16 | 17 | option(CMARK_TESTS "Build cmark-gfm tests and enable testing" ON) 18 | option(CMARK_STATIC "Build static libcmark-gfm library" ON) 19 | option(CMARK_SHARED "Build shared libcmark-gfm library" ON) 20 | option(CMARK_LIB_FUZZER "Build libFuzzer fuzzing harness" OFF) 21 | option(CMARK_FUZZ_QUADRATIC "Build quadratic fuzzing harness" OFF) 22 | 23 | if(CMARK_FUZZ_QUADRATIC) 24 | set(FUZZER_FLAGS "-fsanitize=fuzzer-no-link,address -g") 25 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FUZZER_FLAGS}") 26 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FUZZER_FLAGS}") 27 | set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${FUZZER_FLAGS}") 28 | set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${FUZZER_FLAGS}") 29 | endif() 30 | 31 | add_subdirectory(src) 32 | add_subdirectory(extensions) 33 | if(CMARK_TESTS AND (CMARK_SHARED OR CMARK_STATIC)) 34 | add_subdirectory(api_test) 35 | endif() 36 | add_subdirectory(man) 37 | if(CMARK_TESTS) 38 | enable_testing() 39 | add_subdirectory(test testdir) 40 | endif() 41 | if(CMARK_FUZZ_QUADRATIC) 42 | add_subdirectory(fuzz) 43 | endif() 44 | 45 | if(NOT CMAKE_BUILD_TYPE) 46 | set(CMAKE_BUILD_TYPE "Release" CACHE STRING 47 | "Choose the type of build, options are: Debug Profile Release Asan Ubsan." FORCE) 48 | endif(NOT CMAKE_BUILD_TYPE) 49 | -------------------------------------------------------------------------------- /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI tests 2 | 3 | on: [push, workflow_dispatch] 4 | 5 | jobs: 6 | linux: 7 | 8 | runs-on: ubuntu-latest 9 | strategy: 10 | fail-fast: false 11 | matrix: 12 | cmake_opts: 13 | - '-DCMARK_SHARED=ON' 14 | - '' 15 | compiler: 16 | - c: 'clang' 17 | cpp: 'clang++' 18 | - c: 'gcc' 19 | cpp: 'g++' 20 | env: 21 | CMAKE_OPTIONS: ${{ matrix.cmake_opts }} 22 | CC: ${{ matrix.compiler.c }} 23 | CXX: ${{ matrix.compiler.cpp }} 24 | 25 | steps: 26 | - uses: actions/checkout@v1 27 | - name: Install valgrind 28 | run: | 29 | sudo apt install -y valgrind 30 | - name: Build and test 31 | run: | 32 | make 33 | make test 34 | make leakcheck 35 | 36 | macos: 37 | 38 | runs-on: macOS-latest 39 | strategy: 40 | fail-fast: false 41 | matrix: 42 | cmake_opts: 43 | - '-DCMARK_SHARED=ON' 44 | - '' 45 | compiler: 46 | - c: 'clang' 47 | cpp: 'clang++' 48 | - c: 'gcc' 49 | cpp: 'g++' 50 | env: 51 | CMAKE_OPTIONS: ${{ matrix.cmake_opts }} 52 | CC: ${{ matrix.compiler.c }} 53 | CXX: ${{ matrix.compiler.cpp }} 54 | 55 | steps: 56 | - uses: actions/checkout@v1 57 | - name: Build and test 58 | env: 59 | CMAKE_OPTIONS: -DCMARK_SHARED=OFF 60 | run: | 61 | make 62 | make test 63 | 64 | windows: 65 | 66 | runs-on: windows-latest 67 | strategy: 68 | fail-fast: false 69 | matrix: 70 | cmake_opts: 71 | - '-DCMARK_SHARED=ON' 72 | - '' 73 | env: 74 | CMAKE_OPTIONS: ${{ matrix.cmake_opts }} 75 | 76 | steps: 77 | - uses: actions/checkout@v1 78 | - uses: ilammy/msvc-dev-cmd@v1 79 | - name: Build and test 80 | run: | 81 | chcp 65001 82 | nmake.exe /nologo /f Makefile.nmake test 83 | shell: cmd 84 | -------------------------------------------------------------------------------- /src/footnotes.c: -------------------------------------------------------------------------------- 1 | #include "cmark-gfm.h" 2 | #include "parser.h" 3 | #include "footnotes.h" 4 | #include "inlines.h" 5 | #include "chunk.h" 6 | 7 | static void footnote_free(cmark_map *map, cmark_map_entry *_ref) { 8 | cmark_footnote *ref = (cmark_footnote *)_ref; 9 | cmark_mem *mem = map->mem; 10 | if (ref != NULL) { 11 | mem->free(ref->entry.label); 12 | if (ref->node) 13 | cmark_node_free(ref->node); 14 | mem->free(ref); 15 | } 16 | } 17 | 18 | void cmark_footnote_create(cmark_map *map, cmark_node *node) { 19 | cmark_footnote *ref; 20 | unsigned char *reflabel = normalize_map_label(map->mem, &node->as.literal); 21 | 22 | /* empty footnote name, or composed from only whitespace */ 23 | if (reflabel == NULL) 24 | return; 25 | 26 | assert(map->sorted == NULL); 27 | 28 | ref = (cmark_footnote *)map->mem->calloc(1, sizeof(*ref)); 29 | ref->entry.label = reflabel; 30 | ref->node = node; 31 | ref->entry.age = map->size; 32 | ref->entry.next = map->refs; 33 | 34 | map->refs = (cmark_map_entry *)ref; 35 | map->size++; 36 | } 37 | 38 | cmark_map *cmark_footnote_map_new(cmark_mem *mem) { 39 | return cmark_map_new(mem, footnote_free); 40 | } 41 | 42 | // Before calling `cmark_map_free` on a map with `cmark_footnotes`, first 43 | // unlink all of the footnote nodes before freeing their memory. 44 | // 45 | // Sometimes, two (unused) footnote nodes can end up referencing each other, 46 | // which as they get freed up by calling `cmark_map_free` -> `footnote_free` -> 47 | // etc, can lead to a use-after-free error. 48 | // 49 | // Better to `unlink` every footnote node first, setting their next, prev, and 50 | // parent pointers to NULL, and only then walk thru & free them up. 51 | void cmark_unlink_footnotes_map(cmark_map *map) { 52 | cmark_map_entry *ref; 53 | cmark_map_entry *next; 54 | 55 | ref = map->refs; 56 | while(ref) { 57 | next = ref->next; 58 | if (((cmark_footnote *)ref)->node) { 59 | cmark_node_unlink(((cmark_footnote *)ref)->node); 60 | } 61 | ref = next; 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /test/cmark-fuzz.c: -------------------------------------------------------------------------------- 1 | #include <stdint.h> 2 | #include <stdlib.h> 3 | #include <string.h> 4 | #include "cmark-gfm.h" 5 | #include "cmark-gfm-core-extensions.h" 6 | 7 | const char *extension_names[] = { 8 | "autolink", 9 | "strikethrough", 10 | "table", 11 | "tagfilter", 12 | NULL, 13 | }; 14 | 15 | int LLVMFuzzerInitialize(int *argc, char ***argv) { 16 | cmark_gfm_core_extensions_ensure_registered(); 17 | return 0; 18 | } 19 | 20 | int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 21 | struct __attribute__((packed)) { 22 | int options; 23 | int width; 24 | } fuzz_config; 25 | 26 | if (size >= sizeof(fuzz_config)) { 27 | /* The beginning of `data` is treated as fuzzer configuration */ 28 | memcpy(&fuzz_config, data, sizeof(fuzz_config)); 29 | 30 | /* Remainder of input is the markdown */ 31 | const char *markdown = (const char *)(data + sizeof(fuzz_config)); 32 | const size_t markdown_size = size - sizeof(fuzz_config); 33 | cmark_parser *parser = cmark_parser_new(fuzz_config.options); 34 | 35 | for (const char **it = extension_names; *it; ++it) { 36 | const char *extension_name = *it; 37 | cmark_syntax_extension *syntax_extension = cmark_find_syntax_extension(extension_name); 38 | if (!syntax_extension) { 39 | fprintf(stderr, "%s is not a valid syntax extension\n", extension_name); 40 | abort(); 41 | } 42 | cmark_parser_attach_syntax_extension(parser, syntax_extension); 43 | } 44 | 45 | cmark_parser_feed(parser, markdown, markdown_size); 46 | cmark_node *doc = cmark_parser_finish(parser); 47 | 48 | free(cmark_render_commonmark(doc, fuzz_config.options, fuzz_config.width)); 49 | free(cmark_render_html(doc, fuzz_config.options, NULL)); 50 | free(cmark_render_latex(doc, fuzz_config.options, fuzz_config.width)); 51 | free(cmark_render_man(doc, fuzz_config.options, fuzz_config.width)); 52 | free(cmark_render_xml(doc, fuzz_config.options)); 53 | 54 | cmark_node_free(doc); 55 | cmark_parser_free(parser); 56 | } 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /test/entity_tests.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | 4 | import re 5 | import os 6 | import argparse 7 | import sys 8 | import platform 9 | import html 10 | from cmark import CMark 11 | 12 | def get_entities(): 13 | regex = r'^{\(unsigned char\*\)"([^"]+)", \{([^}]+)\}' 14 | with open(os.path.join(os.path.dirname(__file__), '..', 'src', 'entities.inc')) as f: 15 | code = f.read() 16 | entities = [] 17 | for entity, utf8 in re.findall(regex, code, re.MULTILINE): 18 | utf8 = bytes(map(int, utf8.split(", ")[:-1])).decode('utf-8') 19 | entities.append((entity, utf8)) 20 | return entities 21 | 22 | if __name__ == "__main__": 23 | parser = argparse.ArgumentParser(description='Run cmark tests.') 24 | parser.add_argument('--program', dest='program', nargs='?', default=None, 25 | help='program to test') 26 | parser.add_argument('--library-dir', dest='library_dir', nargs='?', 27 | default=None, help='directory containing dynamic library') 28 | args = parser.parse_args(sys.argv[1:]) 29 | 30 | cmark = CMark(prog=args.program, library_dir=args.library_dir) 31 | 32 | entities = get_entities() 33 | 34 | passed = 0 35 | errored = 0 36 | failed = 0 37 | 38 | exceptions = { 39 | 'quot': '&quot;', 40 | 'QUOT': '&quot;', 41 | 42 | # These are broken, but I'm not too worried about them. 43 | 'nvlt': '&lt;⃒', 44 | 'nvgt': '&gt;⃒', 45 | } 46 | 47 | print("Testing entities:") 48 | for entity, utf8 in entities: 49 | [rc, actual, err] = cmark.to_html("&{};".format(entity)) 50 | check = exceptions.get(entity, utf8) 51 | 52 | if rc != 0: 53 | errored += 1 54 | print(entity, '[ERRORED (return code {})]'.format(rc)) 55 | print(err) 56 | elif check in actual: 57 | passed += 1 58 | else: 59 | print(entity, '[FAILED]') 60 | print(repr(actual)) 61 | failed += 1 62 | 63 | print("{} passed, {} failed, {} errored".format(passed, failed, errored)) 64 | if failed == 0 and errored == 0: 65 | exit(0) 66 | else: 67 | exit(1) 68 | -------------------------------------------------------------------------------- /CheckFileOffsetBits.cmake: -------------------------------------------------------------------------------- 1 | # - Check if _FILE_OFFSET_BITS macro needed for large files 2 | # CHECK_FILE_OFFSET_BITS () 3 | # 4 | # The following variables may be set before calling this macro to 5 | # modify the way the check is run: 6 | # 7 | # CMAKE_REQUIRED_FLAGS = string of compile command line flags 8 | # CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) 9 | # CMAKE_REQUIRED_INCLUDES = list of include directories 10 | # Copyright (c) 2009, Michihiro NAKAJIMA 11 | # 12 | # Redistribution and use is allowed according to the terms of the BSD license. 13 | # For details see the accompanying COPYING-CMAKE-SCRIPTS file. 14 | 15 | #INCLUDE(CheckCSourceCompiles) 16 | 17 | GET_FILENAME_COMPONENT(_selfdir_CheckFileOffsetBits 18 | "${CMAKE_CURRENT_LIST_FILE}" PATH) 19 | 20 | MACRO (CHECK_FILE_OFFSET_BITS) 21 | IF(NOT DEFINED _FILE_OFFSET_BITS) 22 | MESSAGE(STATUS "Checking _FILE_OFFSET_BITS for large files") 23 | TRY_COMPILE(__WITHOUT_FILE_OFFSET_BITS_64 24 | ${CMAKE_CURRENT_BINARY_DIR} 25 | ${_selfdir_CheckFileOffsetBits}/CheckFileOffsetBits.c 26 | COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}) 27 | IF(NOT __WITHOUT_FILE_OFFSET_BITS_64) 28 | TRY_COMPILE(__WITH_FILE_OFFSET_BITS_64 29 | ${CMAKE_CURRENT_BINARY_DIR} 30 | ${_selfdir_CheckFileOffsetBits}/CheckFileOffsetBits.c 31 | COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} -D_FILE_OFFSET_BITS=64) 32 | ENDIF(NOT __WITHOUT_FILE_OFFSET_BITS_64) 33 | 34 | IF(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64) 35 | SET(_FILE_OFFSET_BITS 64 CACHE INTERNAL "_FILE_OFFSET_BITS macro needed for large files") 36 | MESSAGE(STATUS "Checking _FILE_OFFSET_BITS for large files - needed") 37 | ELSE(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64) 38 | SET(_FILE_OFFSET_BITS "" CACHE INTERNAL "_FILE_OFFSET_BITS macro needed for large files") 39 | MESSAGE(STATUS "Checking _FILE_OFFSET_BITS for large files - not needed") 40 | ENDIF(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64) 41 | ENDIF(NOT DEFINED _FILE_OFFSET_BITS) 42 | 43 | ENDMACRO (CHECK_FILE_OFFSET_BITS) 44 | -------------------------------------------------------------------------------- /src/parser.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_PARSER_H 2 | #define CMARK_PARSER_H 3 | 4 | #include <stdio.h> 5 | #include "references.h" 6 | #include "node.h" 7 | #include "buffer.h" 8 | 9 | #ifdef __cplusplus 10 | extern "C" { 11 | #endif 12 | 13 | #define MAX_LINK_LABEL_LENGTH 1000 14 | 15 | struct cmark_parser { 16 | struct cmark_mem *mem; 17 | /* A hashtable of urls in the current document for cross-references */ 18 | struct cmark_map *refmap; 19 | /* The root node of the parser, always a CMARK_NODE_DOCUMENT */ 20 | struct cmark_node *root; 21 | /* The last open block after a line is fully processed */ 22 | struct cmark_node *current; 23 | /* See the documentation for cmark_parser_get_line_number() in cmark.h */ 24 | int line_number; 25 | /* See the documentation for cmark_parser_get_offset() in cmark.h */ 26 | bufsize_t offset; 27 | /* See the documentation for cmark_parser_get_column() in cmark.h */ 28 | bufsize_t column; 29 | /* See the documentation for cmark_parser_get_first_nonspace() in cmark.h */ 30 | bufsize_t first_nonspace; 31 | /* See the documentation for cmark_parser_get_first_nonspace_column() in cmark.h */ 32 | bufsize_t first_nonspace_column; 33 | bufsize_t thematic_break_kill_pos; 34 | /* See the documentation for cmark_parser_get_indent() in cmark.h */ 35 | int indent; 36 | /* See the documentation for cmark_parser_is_blank() in cmark.h */ 37 | bool blank; 38 | /* See the documentation for cmark_parser_has_partially_consumed_tab() in cmark.h */ 39 | bool partially_consumed_tab; 40 | /* Contains the currently processed line */ 41 | cmark_strbuf curline; 42 | /* See the documentation for cmark_parser_get_last_line_length() in cmark.h */ 43 | bufsize_t last_line_length; 44 | /* FIXME: not sure about the difference with curline */ 45 | cmark_strbuf linebuf; 46 | /* Options set by the user, see the Options section in cmark.h */ 47 | int options; 48 | bool last_buffer_ended_with_cr; 49 | size_t total_size; 50 | cmark_llist *syntax_extensions; 51 | cmark_llist *inline_syntax_extensions; 52 | cmark_ispunct_func backslash_ispunct; 53 | }; 54 | 55 | #ifdef __cplusplus 56 | } 57 | #endif 58 | 59 | #endif 60 | -------------------------------------------------------------------------------- /why-cmark-and-not-x.md: -------------------------------------------------------------------------------- 1 | Why use `cmark` and not X? 2 | ========================== 3 | 4 | `hoedown` 5 | --------- 6 | 7 | `hoedown` (which derives from `sundown`) is slightly faster 8 | than `cmark` in our benchmarks (0.21s vs. 0.29s). But both 9 | are much faster than any other available implementations. 10 | 11 | `hoedown` boasts of including "protection against all possible 12 | DOS attacks," but there are some chinks in the armor: 13 | 14 | % time python -c 'print(("[" * 50000) + "a" + ("]" * 50000))' | cmark 15 | ... 16 | user 0m0.073s 17 | % time python -c 'print(("[" * 50000) + "a" + ("]" * 50000))' | hoedown 18 | ... 19 | 0m17.84s 20 | 21 | `hoedown` has many parsing bugs. Here is a selection (as of 22 | v3.0.3): 23 | 24 | % hoedown 25 | - one 26 | - two 27 | 1. three 28 | ^D 29 | <ul> 30 | <li>one 31 | 32 | <ul> 33 | <li>two</li> 34 | <li>three</li> 35 | </ul></li> 36 | </ul> 37 | 38 | 39 | % hoedown 40 | ## hi\### 41 | ^D 42 | <h2>hi\</h2> 43 | 44 | 45 | % hoedown 46 | [ΑΓΩ]: /φου 47 | 48 | [αγω] 49 | ^D 50 | <p>[αγω]</p> 51 | 52 | 53 | % hoedown 54 | ``` 55 | [foo]: /url 56 | ``` 57 | 58 | [foo] 59 | ^D 60 | <p>```</p> 61 | 62 | <p>```</p> 63 | 64 | <p><a href="/url">foo</a></p> 65 | 66 | 67 | % hoedown 68 | [foo](url "ti\*tle") 69 | ^D 70 | <p><a href="url" title="ti\*tle">foo</a></p> 71 | 72 | 73 | % ./hoedown 74 | - one 75 | - two 76 | - three 77 | - four 78 | ^D 79 | <ul> 80 | <li>one 81 | 82 | <ul> 83 | <li>two</li> 84 | <li>three</li> 85 | <li>four</li> 86 | </ul></li> 87 | </ul> 88 | 89 | 90 | `discount` 91 | ---------- 92 | 93 | `cmark` is about six times faster. 94 | 95 | `kramdown` 96 | ---------- 97 | 98 | `cmark` is about a hundred times faster. 99 | 100 | `kramdown` also gets tied in knots by pathological input like 101 | 102 | python -c 'print(("[" * 50000) + "a" + ("]" * 50000))' 103 | 104 | 105 | -------------------------------------------------------------------------------- /tools/xml2md_gfm.xsl: -------------------------------------------------------------------------------- 1 | <?xml version="1.0" encoding="UTF-8"?> 2 | 3 | <!-- 4 | 5 | xml2md_gfm.xsl 6 | ============== 7 | 8 | This XSLT stylesheet is a complement to xml2md.xsl with templates supporting GitHub-flavored Markdown extensions (tables, strike-through). 9 | 10 | --> 11 | 12 | <xsl:stylesheet 13 | version="1.0" 14 | xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 15 | xmlns:md="http://commonmark.org/xml/1.0"> 16 | 17 | 18 | <!-- Import commonmark XSL --> 19 | 20 | <xsl:import href="xml2md.xsl"/> 21 | <xsl:template match="/"> 22 | <xsl:apply-imports/> 23 | </xsl:template> 24 | 25 | <!-- params --> 26 | 27 | <xsl:output method="text" encoding="utf-8"/> 28 | 29 | 30 | <!-- Table --> 31 | 32 | <xsl:template match="md:table"> 33 | <xsl:apply-templates select="." mode="indent-block"/> 34 | <xsl:apply-templates select="md:*"/> 35 | </xsl:template> 36 | 37 | <xsl:template match="md:table_header"> 38 | <xsl:text>| </xsl:text> 39 | <xsl:apply-templates select="md:*"/> 40 | <xsl:text>&#xa; | </xsl:text> 41 | <xsl:for-each select="md:table_cell"> 42 | <xsl:choose> 43 | <xsl:when test="@align = 'right'"> 44 | <xsl:text> ---: |</xsl:text> 45 | </xsl:when> 46 | <xsl:when test="@align = 'left'"> 47 | <xsl:text> :--- |</xsl:text> 48 | </xsl:when> 49 | <xsl:when test="@align = 'center'"> 50 | <xsl:text> :---: |</xsl:text> 51 | </xsl:when> 52 | <xsl:otherwise> 53 | <xsl:text> --- |</xsl:text> 54 | </xsl:otherwise> 55 | </xsl:choose> 56 | </xsl:for-each> 57 | <xsl:text>&#xa;</xsl:text> 58 | </xsl:template> 59 | 60 | <xsl:template match="md:table_cell"> 61 | <xsl:apply-templates select="md:*"/> 62 | <xsl:text>| </xsl:text> 63 | </xsl:template> 64 | 65 | <xsl:template match="md:table_row"> 66 | <xsl:text>| </xsl:text> 67 | <xsl:apply-templates select="md:*"/> 68 | <xsl:text>&#xa;</xsl:text> 69 | </xsl:template> 70 | 71 | 72 | <!-- Striked-through --> 73 | 74 | <xsl:template match="md:strikethrough"> 75 | <xsl:text>~~</xsl:text> 76 | <xsl:apply-templates select="md:*"/> 77 | <xsl:text>~~</xsl:text> 78 | </xsl:template> 79 | 80 | </xsl:stylesheet> 81 | -------------------------------------------------------------------------------- /src/houdini_html_e.c: -------------------------------------------------------------------------------- 1 | #include <assert.h> 2 | #include <stdio.h> 3 | #include <string.h> 4 | 5 | #include "houdini.h" 6 | 7 | /** 8 | * According to the OWASP rules: 9 | * 10 | * & --> &amp; 11 | * < --> &lt; 12 | * > --> &gt; 13 | * " --> &quot; 14 | * ' --> &#x27; &apos; is not recommended 15 | * / --> &#x2F; forward slash is included as it helps end an HTML entity 16 | * 17 | */ 18 | static const char HTML_ESCAPE_TABLE[] = { 19 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 4, 21 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30 | }; 31 | 32 | static const char *HTML_ESCAPES[] = {"", "&quot;", "&amp;", "&#39;", 33 | "&#47;", "&lt;", "&gt;"}; 34 | 35 | int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, bufsize_t size, 36 | int secure) { 37 | bufsize_t i = 0, org, esc = 0; 38 | 39 | while (i < size) { 40 | org = i; 41 | while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0) 42 | i++; 43 | 44 | if (i > org) 45 | cmark_strbuf_put(ob, src + org, i - org); 46 | 47 | /* escaping */ 48 | if (unlikely(i >= size)) 49 | break; 50 | 51 | /* The forward slash and single quote are only escaped in secure mode */ 52 | if ((src[i] == '/' || src[i] == '\'') && !secure) { 53 | cmark_strbuf_putc(ob, src[i]); 54 | } else { 55 | cmark_strbuf_puts(ob, HTML_ESCAPES[esc]); 56 | } 57 | 58 | i++; 59 | } 60 | 61 | return 1; 62 | } 63 | 64 | int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { 65 | return houdini_escape_html0(ob, src, size, 1); 66 | } 67 | -------------------------------------------------------------------------------- /test/roundtrip_tests.py: -------------------------------------------------------------------------------- 1 | import re 2 | import sys 3 | from spec_tests import get_tests, do_test 4 | from cmark import CMark 5 | import argparse 6 | 7 | if __name__ == "__main__": 8 | parser = argparse.ArgumentParser(description='Run cmark roundtrip tests.') 9 | parser.add_argument('-p', '--program', dest='program', nargs='?', default=None, 10 | help='program to test') 11 | parser.add_argument('-s', '--spec', dest='spec', nargs='?', default='spec.txt', 12 | help='path to spec') 13 | parser.add_argument('-P', '--pattern', dest='pattern', nargs='?', 14 | default=None, help='limit to sections matching regex pattern') 15 | parser.add_argument('--library-dir', dest='library_dir', nargs='?', 16 | default=None, help='directory containing dynamic library') 17 | parser.add_argument('--extensions', dest='extensions', nargs='?', 18 | default=None, help='space separated list of extensions to enable') 19 | parser.add_argument('--no-normalize', dest='normalize', 20 | action='store_const', const=False, default=True, 21 | help='do not normalize HTML') 22 | parser.add_argument('-n', '--number', type=int, default=None, 23 | help='only consider the test with the given number') 24 | args = parser.parse_args(sys.argv[1:]) 25 | 26 | spec = sys.argv[1] 27 | 28 | def converter(md, exts): 29 | cmark = CMark(prog=args.program, library_dir=args.library_dir, extensions=args.extensions) 30 | [ec, result, err] = cmark.to_commonmark(md, exts) 31 | if ec == 0: 32 | [ec, html, err] = cmark.to_html(result, exts) 33 | if ec == 0: 34 | # In the commonmark writer we insert dummy HTML 35 | # comments between lists, and between lists and code 36 | # blocks. Strip these out, since the spec uses 37 | # two blank lines instead: 38 | return [ec, re.sub('<!-- end list -->\n', '', html), ''] 39 | else: 40 | return [ec, html, err] 41 | else: 42 | return [ec, result, err] 43 | 44 | tests = get_tests(args.spec) 45 | result_counts = {'pass': 0, 'fail': 0, 'error': 0, 'skip': 0} 46 | for test in tests: 47 | do_test(converter, test, args.normalize, result_counts) 48 | 49 | sys.stdout.buffer.write("{pass} passed, {fail} failed, {error} errored, {skip} skipped\n".format(**result_counts).encode('utf-8')) 50 | exit(result_counts['fail'] + result_counts['error']) 51 | -------------------------------------------------------------------------------- /extensions/ext_scanners.re: -------------------------------------------------------------------------------- 1 | /*!re2c re2c:flags:no-debug-info = 1; */ 2 | /*!re2c re2c:indent:string = ' '; */ 3 | 4 | #include <stdlib.h> 5 | #include "ext_scanners.h" 6 | 7 | bufsize_t _ext_scan_at(bufsize_t (*scanner)(const unsigned char *), unsigned char *ptr, int len, bufsize_t offset) 8 | { 9 | bufsize_t res; 10 | 11 | if (ptr == NULL || offset >= len) { 12 | return 0; 13 | } else { 14 | unsigned char lim = ptr[len]; 15 | 16 | ptr[len] = '\0'; 17 | res = scanner(ptr + offset); 18 | ptr[len] = lim; 19 | } 20 | 21 | return res; 22 | } 23 | 24 | /*!re2c 25 | re2c:define:YYCTYPE = "unsigned char"; 26 | re2c:define:YYCURSOR = p; 27 | re2c:define:YYMARKER = marker; 28 | re2c:yyfill:enable = 0; 29 | 30 | spacechar = [ \t\v\f]; 31 | newline = [\r]?[\n]; 32 | escaped_char = [\\][|!"#$%&'()*+,./:;<=>?@[\\\]^_`{}~-]; 33 | 34 | table_marker = (spacechar*[:]?[-]+[:]?spacechar*); 35 | table_cell = (escaped_char|[^|\r\n])+; 36 | 37 | tasklist = spacechar*("-"|"+"|"*"|[0-9]+.)spacechar+("[ ]"|"[x]")spacechar+; 38 | */ 39 | 40 | bufsize_t _scan_table_start(const unsigned char *p) 41 | { 42 | const unsigned char *marker = NULL; 43 | const unsigned char *start = p; 44 | /*!re2c 45 | [|]? table_marker ([|] table_marker)* [|]? spacechar* newline { 46 | return (bufsize_t)(p - start); 47 | } 48 | * { return 0; } 49 | */ 50 | } 51 | 52 | bufsize_t _scan_table_cell(const unsigned char *p) 53 | { 54 | const unsigned char *marker = NULL; 55 | const unsigned char *start = p; 56 | /*!re2c 57 | // In fact, `table_cell` matches non-empty table cells only. The empty 58 | // string is also a valid table cell, but is handled by the default rule. 59 | // This approach prevents re2c's match-empty-string warning. 60 | table_cell { return (bufsize_t)(p - start); } 61 | * { return 0; } 62 | */ 63 | } 64 | 65 | bufsize_t _scan_table_cell_end(const unsigned char *p) 66 | { 67 | const unsigned char *start = p; 68 | /*!re2c 69 | [|] spacechar* { return (bufsize_t)(p - start); } 70 | * { return 0; } 71 | */ 72 | } 73 | 74 | bufsize_t _scan_table_row_end(const unsigned char *p) 75 | { 76 | const unsigned char *marker = NULL; 77 | const unsigned char *start = p; 78 | /*!re2c 79 | spacechar* newline { return (bufsize_t)(p - start); } 80 | * { return 0; } 81 | */ 82 | } 83 | 84 | bufsize_t _scan_tasklist(const unsigned char *p) 85 | { 86 | const unsigned char *marker = NULL; 87 | const unsigned char *start = p; 88 | /*!re2c 89 | tasklist { return (bufsize_t)(p - start); } 90 | * { return 0; } 91 | */ 92 | } 93 | -------------------------------------------------------------------------------- /src/arena.c: -------------------------------------------------------------------------------- 1 | #include <stdlib.h> 2 | #include <string.h> 3 | #include <stdint.h> 4 | #include "cmark-gfm.h" 5 | #include "cmark-gfm-extension_api.h" 6 | 7 | static struct arena_chunk { 8 | size_t sz, used; 9 | uint8_t push_point; 10 | void *ptr; 11 | struct arena_chunk *prev; 12 | } *A = NULL; 13 | 14 | static struct arena_chunk *alloc_arena_chunk(size_t sz, struct arena_chunk *prev) { 15 | struct arena_chunk *c = (struct arena_chunk *)calloc(1, sizeof(*c)); 16 | if (!c) 17 | abort(); 18 | c->sz = sz; 19 | c->ptr = calloc(1, sz); 20 | if (!c->ptr) 21 | abort(); 22 | c->prev = prev; 23 | return c; 24 | } 25 | 26 | void cmark_arena_push(void) { 27 | if (!A) 28 | return; 29 | A->push_point = 1; 30 | A = alloc_arena_chunk(10240, A); 31 | } 32 | 33 | int cmark_arena_pop(void) { 34 | if (!A) 35 | return 0; 36 | while (A && !A->push_point) { 37 | free(A->ptr); 38 | struct arena_chunk *n = A->prev; 39 | free(A); 40 | A = n; 41 | } 42 | if (A) 43 | A->push_point = 0; 44 | return 1; 45 | } 46 | 47 | static void init_arena(void) { 48 | A = alloc_arena_chunk(4 * 1048576, NULL); 49 | } 50 | 51 | void cmark_arena_reset(void) { 52 | while (A) { 53 | free(A->ptr); 54 | struct arena_chunk *n = A->prev; 55 | free(A); 56 | A = n; 57 | } 58 | } 59 | 60 | static void *arena_calloc(size_t nmem, size_t size) { 61 | if (!A) 62 | init_arena(); 63 | 64 | size_t sz = nmem * size + sizeof(size_t); 65 | 66 | // Round allocation sizes to largest integer size to 67 | // ensure returned memory is correctly aligned 68 | const size_t align = sizeof(size_t) - 1; 69 | sz = (sz + align) & ~align; 70 | 71 | struct arena_chunk *chunk; 72 | if (sz > A->sz) { 73 | A->prev = chunk = alloc_arena_chunk(sz, A->prev); 74 | } else if (sz > A->sz - A->used) { 75 | A = chunk = alloc_arena_chunk(A->sz + A->sz / 2, A); 76 | } else { 77 | chunk = A; 78 | } 79 | void *ptr = (uint8_t *) chunk->ptr + chunk->used; 80 | chunk->used += sz; 81 | *((size_t *) ptr) = sz - sizeof(size_t); 82 | return (uint8_t *) ptr + sizeof(size_t); 83 | } 84 | 85 | static void *arena_realloc(void *ptr, size_t size) { 86 | if (!A) 87 | init_arena(); 88 | 89 | void *new_ptr = arena_calloc(1, size); 90 | if (ptr) 91 | memcpy(new_ptr, ptr, ((size_t *) ptr)[-1]); 92 | return new_ptr; 93 | } 94 | 95 | static void arena_free(void *ptr) { 96 | (void) ptr; 97 | /* no-op */ 98 | } 99 | 100 | cmark_mem CMARK_ARENA_MEM_ALLOCATOR = {arena_calloc, arena_realloc, arena_free}; 101 | 102 | cmark_mem *cmark_get_arena_mem_allocator(void) { 103 | return &CMARK_ARENA_MEM_ALLOCATOR; 104 | } 105 | -------------------------------------------------------------------------------- /man/man1/cmark-gfm.1: -------------------------------------------------------------------------------- 1 | .TH "cmark-gfm" "1" "March 24, 2016" "LOCAL" "General Commands Manual" 2 | .SH "NAME" 3 | \fBcmark\fR 4 | \- convert CommonMark formatted text with GitHub Flavored Markdown extensions to HTML 5 | .SH "SYNOPSIS" 6 | .HP 6n 7 | \fBcmark-gfm\fR 8 | [options] 9 | file* 10 | .SH "DESCRIPTION" 11 | \fBcmark-gfm\fR 12 | converts Markdown formatted plain text to either HTML, groff man, 13 | CommonMark XML, LaTeX, or CommonMark, using the conventions 14 | described in the CommonMark spec. It reads input from \fIstdin\fR 15 | or the specified files (concatenating their contents) and writes 16 | output to \fIstdout\fR. 17 | .SH "OPTIONS" 18 | .TP 12n 19 | .B \-\-to, \-t \f[I]FORMAT\f[] 20 | Specify output format (\f[C]html\f[], \f[C]man\f[], \f[C]xml\f[], 21 | \f[C]latex\f[], \f[C]commonmark\f[]). 22 | .TP 12n 23 | .B \-\-width \f[I]WIDTH\f[] 24 | Specify a column width to which to wrap the output. For no wrapping, use 25 | the value 0 (the default). This option currently only affects the 26 | commonmark, latex, and man renderers. 27 | .TP 12n 28 | .B \-\-hardbreaks 29 | Render soft breaks (newlines inside paragraphs in the CommonMark source) 30 | as hard line breaks in the target format. If this option is specified, 31 | hard wrapping is disabled for CommonMark output, regardless of the value 32 | given with \-\-width. 33 | .TP 12n 34 | .B \-\-nobreaks 35 | Render soft breaks as spaces. If this option is specified, 36 | hard wrapping is disabled for all output formats, regardless of the value 37 | given with \-\-width. 38 | .TP 12n 39 | .B \-\-sourcepos 40 | Include source position attribute. 41 | .TP 12n 42 | .B \-\-normalize 43 | Consolidate adjacent text nodes. 44 | .TP 12n 45 | .B \-\-extension, \-e \f[I]EXTENSION_NAME\f[] 46 | Specify an extension name to use. 47 | .TP 12n 48 | .B \-\-list\-extensions 49 | List available extensions and quit. 50 | .TP 12n 51 | .B \-\-validate-utf8 52 | Validate UTF-8, replacing illegal sequences with U+FFFD. 53 | .TP 12n 54 | .B \-\-smart 55 | Use smart punctuation. Straight double and single quotes will 56 | be rendered as curly quotes, depending on their position. 57 | \f[C]\-\-\f[] will be rendered as an en-dash. 58 | \f[C]\-\-\-\f[] will be rendered as an em-dash. 59 | \f[C]...\f[] will be rendered as ellipses. 60 | .TP 12n 61 | .B \-\-unsafe 62 | Render raw HTML and potentially dangerous URLs. 63 | (Raw HTML is not replaced by a placeholder comment; potentially 64 | dangerous URLs are not replaced by empty strings.) Dangerous 65 | URLs are those that begin with `javascript:`, `vbscript:`, 66 | `file:`, or `data:` (except for `image/png`, `image/gif`, 67 | `image/jpeg`, or `image/webp` mime types). 68 | .TP 12n 69 | .B \-\-help 70 | Print usage information. 71 | .TP 12n 72 | .B \-\-version 73 | Print version. 74 | .SH "AUTHORS" 75 | John MacFarlane, Vicent Marti, Kārlis Gaņģis, Nick Wellnhofer. 76 | .SH "SEE ALSO" 77 | .PP 78 | CommonMark spec: \f[C]http://spec.commonmark.org\f[]. 79 | -------------------------------------------------------------------------------- /api_test/harness.c: -------------------------------------------------------------------------------- 1 | #define _DEFAULT_SOURCE 2 | #include <stdarg.h> 3 | #include <stdio.h> 4 | #include <stdlib.h> 5 | #include <string.h> 6 | 7 | #include "harness.h" 8 | 9 | test_batch_runner *test_batch_runner_new() { 10 | return (test_batch_runner *)calloc(1, sizeof(test_batch_runner)); 11 | } 12 | 13 | static void test_result(test_batch_runner *runner, int cond, const char *msg, 14 | va_list ap) { 15 | ++runner->test_num; 16 | 17 | if (cond) { 18 | ++runner->num_passed; 19 | } else { 20 | fprintf(stderr, "FAILED test %d: ", runner->test_num); 21 | vfprintf(stderr, msg, ap); 22 | fprintf(stderr, "\n"); 23 | ++runner->num_failed; 24 | } 25 | } 26 | 27 | void SKIP(test_batch_runner *runner, int num_tests) { 28 | runner->test_num += num_tests; 29 | runner->num_skipped += num_tests; 30 | } 31 | 32 | void OK(test_batch_runner *runner, int cond, const char *msg, ...) { 33 | va_list ap; 34 | va_start(ap, msg); 35 | test_result(runner, cond, msg, ap); 36 | va_end(ap); 37 | } 38 | 39 | void INT_EQ(test_batch_runner *runner, int got, int expected, const char *msg, 40 | ...) { 41 | int cond = got == expected; 42 | 43 | va_list ap; 44 | va_start(ap, msg); 45 | test_result(runner, cond, msg, ap); 46 | va_end(ap); 47 | 48 | if (!cond) { 49 | fprintf(stderr, " Got: %d\n", got); 50 | fprintf(stderr, " Expected: %d\n", expected); 51 | } 52 | } 53 | 54 | #ifndef _WIN32 55 | #include <unistd.h> 56 | 57 | static char *write_tmp(char const *header, char const *data) { 58 | char *name = strdup("/tmp/fileXXXXXX"); 59 | int fd = mkstemp(name); 60 | FILE *f = fdopen(fd, "w+"); 61 | fputs(header, f); 62 | fwrite(data, 1, strlen(data), f); 63 | fclose(f); 64 | return name; 65 | } 66 | 67 | #endif 68 | 69 | void STR_EQ(test_batch_runner *runner, const char *got, const char *expected, 70 | const char *msg, ...) { 71 | int cond = strcmp(got, expected) == 0; 72 | 73 | va_list ap; 74 | va_start(ap, msg); 75 | test_result(runner, cond, msg, ap); 76 | va_end(ap); 77 | 78 | if (!cond) { 79 | #ifndef _WIN32 80 | char *got_fn = write_tmp("actual\n", got); 81 | char *expected_fn = write_tmp("expected\n", expected); 82 | char buf[1024]; 83 | snprintf(buf, sizeof(buf), "git diff --no-index %s %s", expected_fn, got_fn); 84 | system(buf); 85 | remove(got_fn); 86 | remove(expected_fn); 87 | free(got_fn); 88 | free(expected_fn); 89 | #else 90 | fprintf(stderr, " Got: \"%s\"\n", got); 91 | fprintf(stderr, " Expected: \"%s\"\n", expected); 92 | #endif 93 | } 94 | } 95 | 96 | int test_ok(test_batch_runner *runner) { return runner->num_failed == 0; } 97 | 98 | void test_print_summary(test_batch_runner *runner) { 99 | int num_passed = runner->num_passed; 100 | int num_skipped = runner->num_skipped; 101 | int num_failed = runner->num_failed; 102 | 103 | fprintf(stderr, "%d tests passed, %d failed, %d skipped\n", num_passed, 104 | num_failed, num_skipped); 105 | 106 | if (test_ok(runner)) { 107 | fprintf(stderr, "PASS\n"); 108 | } else { 109 | fprintf(stderr, "FAIL\n"); 110 | } 111 | } 112 | -------------------------------------------------------------------------------- /src/buffer.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_BUFFER_H 2 | #define CMARK_BUFFER_H 3 | 4 | #include <stddef.h> 5 | #include <stdarg.h> 6 | #include <string.h> 7 | #include <limits.h> 8 | #include <stdint.h> 9 | #include "config.h" 10 | #include "cmark-gfm.h" 11 | 12 | #ifdef __cplusplus 13 | extern "C" { 14 | #endif 15 | 16 | typedef struct { 17 | cmark_mem *mem; 18 | unsigned char *ptr; 19 | bufsize_t asize, size; 20 | } cmark_strbuf; 21 | 22 | extern unsigned char cmark_strbuf__initbuf[]; 23 | 24 | #define CMARK_BUF_INIT(mem) \ 25 | { mem, cmark_strbuf__initbuf, 0, 0 } 26 | 27 | /** 28 | * Initialize a cmark_strbuf structure. 29 | * 30 | * For the cases where CMARK_BUF_INIT cannot be used to do static 31 | * initialization. 32 | */ 33 | CMARK_GFM_EXPORT 34 | void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf, 35 | bufsize_t initial_size); 36 | 37 | /** 38 | * Grow the buffer to hold at least `target_size` bytes. 39 | */ 40 | CMARK_GFM_EXPORT 41 | void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size); 42 | 43 | CMARK_GFM_EXPORT 44 | void cmark_strbuf_free(cmark_strbuf *buf); 45 | 46 | CMARK_GFM_EXPORT 47 | void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b); 48 | 49 | CMARK_GFM_EXPORT 50 | bufsize_t cmark_strbuf_len(const cmark_strbuf *buf); 51 | 52 | CMARK_GFM_EXPORT 53 | int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b); 54 | 55 | CMARK_GFM_EXPORT 56 | unsigned char *cmark_strbuf_detach(cmark_strbuf *buf); 57 | 58 | CMARK_GFM_EXPORT 59 | void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, 60 | const cmark_strbuf *buf); 61 | 62 | static CMARK_INLINE const char *cmark_strbuf_cstr(const cmark_strbuf *buf) { 63 | return (char *)buf->ptr; 64 | } 65 | 66 | #define cmark_strbuf_at(buf, n) ((buf)->ptr[n]) 67 | 68 | CMARK_GFM_EXPORT 69 | void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, 70 | bufsize_t len); 71 | 72 | CMARK_GFM_EXPORT 73 | void cmark_strbuf_sets(cmark_strbuf *buf, const char *string); 74 | 75 | CMARK_GFM_EXPORT 76 | void cmark_strbuf_putc(cmark_strbuf *buf, int c); 77 | 78 | CMARK_GFM_EXPORT 79 | void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, 80 | bufsize_t len); 81 | 82 | CMARK_GFM_EXPORT 83 | void cmark_strbuf_puts(cmark_strbuf *buf, const char *string); 84 | 85 | CMARK_GFM_EXPORT 86 | void cmark_strbuf_clear(cmark_strbuf *buf); 87 | 88 | CMARK_GFM_EXPORT 89 | bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos); 90 | 91 | CMARK_GFM_EXPORT 92 | bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos); 93 | 94 | CMARK_GFM_EXPORT 95 | void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n); 96 | 97 | CMARK_GFM_EXPORT 98 | void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len); 99 | 100 | CMARK_GFM_EXPORT 101 | void cmark_strbuf_rtrim(cmark_strbuf *buf); 102 | 103 | CMARK_GFM_EXPORT 104 | void cmark_strbuf_trim(cmark_strbuf *buf); 105 | 106 | CMARK_GFM_EXPORT 107 | void cmark_strbuf_normalize_whitespace(cmark_strbuf *s); 108 | 109 | CMARK_GFM_EXPORT 110 | void cmark_strbuf_unescape(cmark_strbuf *s); 111 | 112 | #ifdef __cplusplus 113 | } 114 | #endif 115 | 116 | #endif 117 | -------------------------------------------------------------------------------- /.github/workflows/codeql.yml: -------------------------------------------------------------------------------- 1 | # For most projects, this workflow file will not need changing; you simply need 2 | # to commit it to your repository. 3 | # 4 | # You may wish to alter this file to override the set of languages analyzed, 5 | # or to provide custom queries or build logic. 6 | # 7 | # ******** NOTE ******** 8 | # We have attempted to detect the languages in your repository. Please check 9 | # the `language` matrix defined below to confirm you have the correct set of 10 | # supported CodeQL languages. 11 | # 12 | name: "CodeQL" 13 | 14 | on: 15 | push: 16 | branches: [ "master" ] 17 | pull_request: 18 | # The branches below must be a subset of the branches above 19 | branches: [ "master" ] 20 | schedule: 21 | - cron: '45 14 * * 3' 22 | 23 | jobs: 24 | analyze: 25 | name: Analyze 26 | runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }} 27 | timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }} 28 | permissions: 29 | actions: read 30 | contents: read 31 | security-events: write 32 | 33 | strategy: 34 | fail-fast: false 35 | matrix: 36 | language: [ 'cpp', 'javascript', 'python', 'ruby' ] 37 | # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby', 'swift' ] 38 | # Use only 'java' to analyze code written in Java, Kotlin or both 39 | # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both 40 | # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support 41 | 42 | steps: 43 | - name: Checkout repository 44 | uses: actions/checkout@v3 45 | 46 | # Initializes the CodeQL tools for scanning. 47 | - name: Initialize CodeQL 48 | uses: github/codeql-action/init@v2 49 | with: 50 | languages: ${{ matrix.language }} 51 | # If you wish to specify custom queries, you can do so here or in a config file. 52 | # By default, queries listed here will override any specified in a config file. 53 | # Prefix the list here with "+" to use these queries and those in the config file. 54 | 55 | # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs 56 | # queries: security-extended,security-and-quality 57 | 58 | 59 | # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift). 60 | # If this step fails, then you should remove it and run the build manually (see below) 61 | - name: Autobuild 62 | uses: github/codeql-action/autobuild@v2 63 | 64 | # ℹ️ Command-line programs to run using the OS shell. 65 | # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun 66 | 67 | # If the Autobuild fails above, remove it and uncomment the following three lines. 68 | # modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance. 69 | 70 | # - run: | 71 | # echo "Run, Build Application using script" 72 | # ./location_of_script_within_repo/buildscript.sh 73 | 74 | - name: Perform CodeQL Analysis 75 | uses: github/codeql-action/analyze@v2 76 | with: 77 | category: "/language:${{matrix.language}}" 78 | -------------------------------------------------------------------------------- /FindAsan.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # The MIT License (MIT) 3 | # 4 | # Copyright (c) 2013 Matthew Arsenault 5 | # 6 | # Permission is hereby granted, free of charge, to any person obtaining a copy 7 | # of this software and associated documentation files (the "Software"), to deal 8 | # in the Software without restriction, including without limitation the rights 9 | # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | # copies of the Software, and to permit persons to whom the Software is 11 | # furnished to do so, subject to the following conditions: 12 | # 13 | # The above copyright notice and this permission notice shall be included in 14 | # all copies or substantial portions of the Software. 15 | # 16 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 | # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 | # THE SOFTWARE. 23 | # 24 | # This module tests if address sanitizer is supported by the compiler, 25 | # and creates a ASan build type (i.e. set CMAKE_BUILD_TYPE=ASan to use 26 | # it). This sets the following variables: 27 | # 28 | # CMAKE_C_FLAGS_ASAN - Flags to use for C with asan 29 | # CMAKE_CXX_FLAGS_ASAN - Flags to use for C++ with asan 30 | # HAVE_ADDRESS_SANITIZER - True or false if the ASan build type is available 31 | 32 | include(CheckCCompilerFlag) 33 | 34 | # Set -Werror to catch "argument unused during compilation" warnings 35 | set(CMAKE_REQUIRED_FLAGS "-Werror -faddress-sanitizer") # Also needs to be a link flag for test to pass 36 | check_c_compiler_flag("-faddress-sanitizer" HAVE_FLAG_ADDRESS_SANITIZER) 37 | 38 | set(CMAKE_REQUIRED_FLAGS "-Werror -fsanitize=address") # Also needs to be a link flag for test to pass 39 | check_c_compiler_flag("-fsanitize=address" HAVE_FLAG_SANITIZE_ADDRESS) 40 | 41 | unset(CMAKE_REQUIRED_FLAGS) 42 | 43 | if(HAVE_FLAG_SANITIZE_ADDRESS) 44 | # Clang 3.2+ use this version 45 | set(ADDRESS_SANITIZER_FLAG "-fsanitize=address") 46 | elseif(HAVE_FLAG_ADDRESS_SANITIZER) 47 | # Older deprecated flag for ASan 48 | set(ADDRESS_SANITIZER_FLAG "-faddress-sanitizer") 49 | endif() 50 | 51 | if(NOT ADDRESS_SANITIZER_FLAG) 52 | return() 53 | else(NOT ADDRESS_SANITIZER_FLAG) 54 | set(HAVE_ADDRESS_SANITIZER FALSE) 55 | endif() 56 | 57 | set(HAVE_ADDRESS_SANITIZER TRUE) 58 | 59 | set(CMAKE_C_FLAGS_ASAN "-O1 -g ${ADDRESS_SANITIZER_FLAG} -fno-omit-frame-pointer -fno-optimize-sibling-calls" 60 | CACHE STRING "Flags used by the C compiler during ASan builds." 61 | FORCE) 62 | set(CMAKE_CXX_FLAGS_ASAN "-O1 -g ${ADDRESS_SANITIZER_FLAG} -fno-omit-frame-pointer -fno-optimize-sibling-calls" 63 | CACHE STRING "Flags used by the C++ compiler during ASan builds." 64 | FORCE) 65 | set(CMAKE_EXE_LINKER_FLAGS_ASAN "${ADDRESS_SANITIZER_FLAG}" 66 | CACHE STRING "Flags used for linking binaries during ASan builds." 67 | FORCE) 68 | set(CMAKE_SHARED_LINKER_FLAGS_ASAN "${ADDRESS_SANITIZER_FLAG}" 69 | CACHE STRING "Flags used by the shared libraries linker during ASan builds." 70 | FORCE) 71 | mark_as_advanced(CMAKE_C_FLAGS_ASAN 72 | CMAKE_CXX_FLAGS_ASAN 73 | CMAKE_EXE_LINKER_FLAGS_ASAN 74 | CMAKE_SHARED_LINKER_FLAGS_ASAN) 75 | -------------------------------------------------------------------------------- /src/houdini_href_e.c: -------------------------------------------------------------------------------- 1 | #include <assert.h> 2 | #include <stdio.h> 3 | #include <string.h> 4 | 5 | #include "houdini.h" 6 | 7 | /* 8 | * The following characters will not be escaped: 9 | * 10 | * -_.+!*'(),%#@?=;:/,+&$~ alphanum 11 | * 12 | * Note that this character set is the addition of: 13 | * 14 | * - The characters which are safe to be in an URL 15 | * - The characters which are *not* safe to be in 16 | * an URL because they are RESERVED characters. 17 | * 18 | * We assume (lazily) that any RESERVED char that 19 | * appears inside an URL is actually meant to 20 | * have its native function (i.e. as an URL 21 | * component/separator) and hence needs no escaping. 22 | * 23 | * There are two exceptions: the chacters & (amp) 24 | * and ' (single quote) do not appear in the table. 25 | * They are meant to appear in the URL as components, 26 | * yet they require special HTML-entity escaping 27 | * to generate valid HTML markup. 28 | * 29 | * All other characters will be escaped to %XX. 30 | * 31 | */ 32 | static const char HREF_SAFE[] = { 33 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 35 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 36 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 37 | 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 38 | 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 41 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44 | }; 45 | 46 | int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { 47 | static const uint8_t hex_chars[] = "0123456789ABCDEF"; 48 | bufsize_t i = 0, org; 49 | uint8_t hex_str[3]; 50 | 51 | hex_str[0] = '%'; 52 | 53 | while (i < size) { 54 | org = i; 55 | while (i < size && HREF_SAFE[src[i]] != 0) 56 | i++; 57 | 58 | if (likely(i > org)) 59 | cmark_strbuf_put(ob, src + org, i - org); 60 | 61 | /* escaping */ 62 | if (i >= size) 63 | break; 64 | 65 | switch (src[i]) { 66 | /* amp appears all the time in URLs, but needs 67 | * HTML-entity escaping to be inside an href */ 68 | case '&': 69 | cmark_strbuf_puts(ob, "&amp;"); 70 | break; 71 | 72 | /* the single quote is a valid URL character 73 | * according to the standard; it needs HTML 74 | * entity escaping too */ 75 | case '\'': 76 | cmark_strbuf_puts(ob, "&#x27;"); 77 | break; 78 | 79 | /* the space can be escaped to %20 or a plus 80 | * sign. we're going with the generic escape 81 | * for now. the plus thing is more commonly seen 82 | * when building GET strings */ 83 | #if 0 84 | case ' ': 85 | cmark_strbuf_putc(ob, '+'); 86 | break; 87 | #endif 88 | 89 | /* every other character goes with a %XX escaping */ 90 | default: 91 | hex_str[1] = hex_chars[(src[i] >> 4) & 0xF]; 92 | hex_str[2] = hex_chars[src[i] & 0xF]; 93 | cmark_strbuf_put(ob, hex_str, 3); 94 | } 95 | 96 | i++; 97 | } 98 | 99 | return 1; 100 | } 101 | -------------------------------------------------------------------------------- /fuzz/fuzz_quadratic.c: -------------------------------------------------------------------------------- 1 | #include <stdint.h> 2 | #include <stdlib.h> 3 | #include <string.h> 4 | #include "cmark-gfm.h" 5 | #include "cmark-gfm-core-extensions.h" 6 | #include <sys/types.h> 7 | #include <sys/stat.h> 8 | #include <fcntl.h> 9 | #include <unistd.h> 10 | 11 | const char *extension_names[] = { 12 | "autolink", 13 | "strikethrough", 14 | "table", 15 | "tagfilter", 16 | NULL, 17 | }; 18 | 19 | int LLVMFuzzerInitialize(int *argc, char ***argv) { 20 | cmark_gfm_core_extensions_ensure_registered(); 21 | return 0; 22 | } 23 | 24 | int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 25 | struct __attribute__((packed)) { 26 | int options; 27 | int width; 28 | uint8_t splitpoint; 29 | uint8_t repeatlen; 30 | } fuzz_config; 31 | 32 | if (size >= sizeof(fuzz_config)) { 33 | /* The beginning of `data` is treated as fuzzer configuration */ 34 | memcpy(&fuzz_config, data, sizeof(fuzz_config)); 35 | 36 | /* Test options that are used by GitHub. */ 37 | fuzz_config.options = CMARK_OPT_UNSAFE | CMARK_OPT_FOOTNOTES | CMARK_OPT_GITHUB_PRE_LANG | CMARK_OPT_HARDBREAKS; 38 | 39 | /* Remainder of input is the markdown */ 40 | const char *markdown0 = (const char *)(data + sizeof(fuzz_config)); 41 | const size_t markdown_size0 = size - sizeof(fuzz_config); 42 | char markdown[0x80000]; 43 | if (markdown_size0 <= sizeof(markdown)) { 44 | size_t markdown_size = 0; 45 | if (fuzz_config.splitpoint <= markdown_size0 && 0 < fuzz_config.repeatlen && 46 | fuzz_config.repeatlen <= markdown_size0 - fuzz_config.splitpoint) { 47 | const size_t size_after_splitpoint = markdown_size0 - fuzz_config.splitpoint - fuzz_config.repeatlen; 48 | memcpy(&markdown[markdown_size], &markdown0[0], fuzz_config.splitpoint); 49 | markdown_size += fuzz_config.splitpoint; 50 | 51 | while (markdown_size + fuzz_config.repeatlen + size_after_splitpoint <= sizeof(markdown)) { 52 | memcpy(&markdown[markdown_size], &markdown0[fuzz_config.splitpoint], 53 | fuzz_config.repeatlen); 54 | markdown_size += fuzz_config.repeatlen; 55 | } 56 | memcpy(&markdown[markdown_size], &markdown0[fuzz_config.splitpoint + fuzz_config.repeatlen], 57 | size_after_splitpoint); 58 | markdown_size += size_after_splitpoint; 59 | } else { 60 | markdown_size = markdown_size0; 61 | memcpy(markdown, markdown0, markdown_size); 62 | } 63 | 64 | cmark_parser *parser = cmark_parser_new(fuzz_config.options); 65 | 66 | for (const char **it = extension_names; *it; ++it) { 67 | const char *extension_name = *it; 68 | cmark_syntax_extension *syntax_extension = cmark_find_syntax_extension(extension_name); 69 | if (!syntax_extension) { 70 | fprintf(stderr, "%s is not a valid syntax extension\n", extension_name); 71 | abort(); 72 | } 73 | cmark_parser_attach_syntax_extension(parser, syntax_extension); 74 | } 75 | 76 | cmark_parser_feed(parser, markdown, markdown_size); 77 | cmark_node *doc = cmark_parser_finish(parser); 78 | 79 | free(cmark_render_html(doc, fuzz_config.options, NULL)); 80 | free(cmark_render_xml(doc, fuzz_config.options)); 81 | free(cmark_render_man(doc, fuzz_config.options, 80)); 82 | free(cmark_render_commonmark(doc, fuzz_config.options, 80)); 83 | free(cmark_render_plaintext(doc, fuzz_config.options, 80)); 84 | free(cmark_render_latex(doc, fuzz_config.options, 80)); 85 | 86 | cmark_node_free(doc); 87 | cmark_parser_free(parser); 88 | } 89 | } 90 | return 0; 91 | } 92 | -------------------------------------------------------------------------------- /src/map.c: -------------------------------------------------------------------------------- 1 | #include "map.h" 2 | #include "utf8.h" 3 | #include "parser.h" 4 | 5 | // normalize map label: collapse internal whitespace to single space, 6 | // remove leading/trailing whitespace, case fold 7 | // Return NULL if the label is actually empty (i.e. composed solely from 8 | // whitespace) 9 | unsigned char *normalize_map_label(cmark_mem *mem, cmark_chunk *ref) { 10 | cmark_strbuf normalized = CMARK_BUF_INIT(mem); 11 | unsigned char *result; 12 | 13 | if (ref == NULL) 14 | return NULL; 15 | 16 | if (ref->len == 0) 17 | return NULL; 18 | 19 | cmark_utf8proc_case_fold(&normalized, ref->data, ref->len); 20 | cmark_strbuf_trim(&normalized); 21 | cmark_strbuf_normalize_whitespace(&normalized); 22 | 23 | result = cmark_strbuf_detach(&normalized); 24 | assert(result); 25 | 26 | if (result[0] == '\0') { 27 | mem->free(result); 28 | return NULL; 29 | } 30 | 31 | return result; 32 | } 33 | 34 | static int 35 | labelcmp(const unsigned char *a, const unsigned char *b) { 36 | return strcmp((const char *)a, (const char *)b); 37 | } 38 | 39 | static int 40 | refcmp(const void *p1, const void *p2) { 41 | cmark_map_entry *r1 = *(cmark_map_entry **)p1; 42 | cmark_map_entry *r2 = *(cmark_map_entry **)p2; 43 | int res = labelcmp(r1->label, r2->label); 44 | return res ? res : ((int)r1->age - (int)r2->age); 45 | } 46 | 47 | static int 48 | refsearch(const void *label, const void *p2) { 49 | cmark_map_entry *ref = *(cmark_map_entry **)p2; 50 | return labelcmp((const unsigned char *)label, ref->label); 51 | } 52 | 53 | static void sort_map(cmark_map *map) { 54 | size_t i = 0, last = 0, size = map->size; 55 | cmark_map_entry *r = map->refs, **sorted = NULL; 56 | 57 | sorted = (cmark_map_entry **)map->mem->calloc(size, sizeof(cmark_map_entry *)); 58 | while (r) { 59 | sorted[i++] = r; 60 | r = r->next; 61 | } 62 | 63 | qsort(sorted, size, sizeof(cmark_map_entry *), refcmp); 64 | 65 | for (i = 1; i < size; i++) { 66 | if (labelcmp(sorted[i]->label, sorted[last]->label) != 0) 67 | sorted[++last] = sorted[i]; 68 | } 69 | 70 | map->sorted = sorted; 71 | map->size = last + 1; 72 | } 73 | 74 | cmark_map_entry *cmark_map_lookup(cmark_map *map, cmark_chunk *label) { 75 | cmark_map_entry **ref = NULL; 76 | cmark_map_entry *r = NULL; 77 | unsigned char *norm; 78 | 79 | if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH) 80 | return NULL; 81 | 82 | if (map == NULL || !map->size) 83 | return NULL; 84 | 85 | norm = normalize_map_label(map->mem, label); 86 | if (norm == NULL) 87 | return NULL; 88 | 89 | if (!map->sorted) 90 | sort_map(map); 91 | 92 | ref = (cmark_map_entry **)bsearch(norm, map->sorted, map->size, sizeof(cmark_map_entry *), refsearch); 93 | map->mem->free(norm); 94 | 95 | if (ref != NULL) { 96 | r = ref[0]; 97 | /* Check for expansion limit */ 98 | if (r->size > map->max_ref_size - map->ref_size) 99 | return NULL; 100 | map->ref_size += r->size; 101 | } 102 | 103 | return r; 104 | } 105 | 106 | void cmark_map_free(cmark_map *map) { 107 | cmark_map_entry *ref; 108 | 109 | if (map == NULL) 110 | return; 111 | 112 | ref = map->refs; 113 | while (ref) { 114 | cmark_map_entry *next = ref->next; 115 | map->free(map, ref); 116 | ref = next; 117 | } 118 | 119 | map->mem->free(map->sorted); 120 | map->mem->free(map); 121 | } 122 | 123 | cmark_map *cmark_map_new(cmark_mem *mem, cmark_map_free_f free) { 124 | cmark_map *map = (cmark_map *)mem->calloc(1, sizeof(cmark_map)); 125 | map->mem = mem; 126 | map->free = free; 127 | map->max_ref_size = UINT_MAX; 128 | return map; 129 | } 130 | -------------------------------------------------------------------------------- /src/scanners.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_SCANNERS_H 2 | #define CMARK_SCANNERS_H 3 | 4 | #include "cmark-gfm.h" 5 | #include "chunk.h" 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, 12 | bufsize_t offset); 13 | bufsize_t _scan_scheme(const unsigned char *p); 14 | bufsize_t _scan_autolink_uri(const unsigned char *p); 15 | bufsize_t _scan_autolink_email(const unsigned char *p); 16 | bufsize_t _scan_html_tag(const unsigned char *p); 17 | bufsize_t _scan_liberal_html_tag(const unsigned char *p); 18 | bufsize_t _scan_html_comment(const unsigned char *p); 19 | bufsize_t _scan_html_pi(const unsigned char *p); 20 | bufsize_t _scan_html_declaration(const unsigned char *p); 21 | bufsize_t _scan_html_cdata(const unsigned char *p); 22 | bufsize_t _scan_html_block_start(const unsigned char *p); 23 | bufsize_t _scan_html_block_start_7(const unsigned char *p); 24 | bufsize_t _scan_html_block_end_1(const unsigned char *p); 25 | bufsize_t _scan_html_block_end_2(const unsigned char *p); 26 | bufsize_t _scan_html_block_end_3(const unsigned char *p); 27 | bufsize_t _scan_html_block_end_4(const unsigned char *p); 28 | bufsize_t _scan_html_block_end_5(const unsigned char *p); 29 | bufsize_t _scan_link_title(const unsigned char *p); 30 | bufsize_t _scan_spacechars(const unsigned char *p); 31 | bufsize_t _scan_atx_heading_start(const unsigned char *p); 32 | bufsize_t _scan_setext_heading_line(const unsigned char *p); 33 | bufsize_t _scan_open_code_fence(const unsigned char *p); 34 | bufsize_t _scan_close_code_fence(const unsigned char *p); 35 | bufsize_t _scan_entity(const unsigned char *p); 36 | bufsize_t _scan_dangerous_url(const unsigned char *p); 37 | bufsize_t _scan_footnote_definition(const unsigned char *p); 38 | 39 | #define scan_scheme(c, n) _scan_at(&_scan_scheme, c, n) 40 | #define scan_autolink_uri(c, n) _scan_at(&_scan_autolink_uri, c, n) 41 | #define scan_autolink_email(c, n) _scan_at(&_scan_autolink_email, c, n) 42 | #define scan_html_tag(c, n) _scan_at(&_scan_html_tag, c, n) 43 | #define scan_liberal_html_tag(c, n) _scan_at(&_scan_liberal_html_tag, c, n) 44 | #define scan_html_comment(c, n) _scan_at(&_scan_html_comment, c, n) 45 | #define scan_html_pi(c, n) _scan_at(&_scan_html_pi, c, n) 46 | #define scan_html_declaration(c, n) _scan_at(&_scan_html_declaration, c, n) 47 | #define scan_html_cdata(c, n) _scan_at(&_scan_html_cdata, c, n) 48 | #define scan_html_block_start(c, n) _scan_at(&_scan_html_block_start, c, n) 49 | #define scan_html_block_start_7(c, n) _scan_at(&_scan_html_block_start_7, c, n) 50 | #define scan_html_block_end_1(c, n) _scan_at(&_scan_html_block_end_1, c, n) 51 | #define scan_html_block_end_2(c, n) _scan_at(&_scan_html_block_end_2, c, n) 52 | #define scan_html_block_end_3(c, n) _scan_at(&_scan_html_block_end_3, c, n) 53 | #define scan_html_block_end_4(c, n) _scan_at(&_scan_html_block_end_4, c, n) 54 | #define scan_html_block_end_5(c, n) _scan_at(&_scan_html_block_end_5, c, n) 55 | #define scan_link_title(c, n) _scan_at(&_scan_link_title, c, n) 56 | #define scan_spacechars(c, n) _scan_at(&_scan_spacechars, c, n) 57 | #define scan_atx_heading_start(c, n) _scan_at(&_scan_atx_heading_start, c, n) 58 | #define scan_setext_heading_line(c, n) \ 59 | _scan_at(&_scan_setext_heading_line, c, n) 60 | #define scan_open_code_fence(c, n) _scan_at(&_scan_open_code_fence, c, n) 61 | #define scan_close_code_fence(c, n) _scan_at(&_scan_close_code_fence, c, n) 62 | #define scan_entity(c, n) _scan_at(&_scan_entity, c, n) 63 | #define scan_dangerous_url(c, n) _scan_at(&_scan_dangerous_url, c, n) 64 | #define scan_footnote_definition(c, n) _scan_at(&_scan_footnote_definition, c, n) 65 | 66 | #ifdef __cplusplus 67 | } 68 | #endif 69 | 70 | #endif 71 | -------------------------------------------------------------------------------- /bench/samples/lorem1.md: -------------------------------------------------------------------------------- 1 | Lorem ipsum dolor sit amet, __consectetur__ adipiscing elit. Cras imperdiet nec erat ac condimentum. Nulla vel rutrum ligula. Sed hendrerit interdum orci a posuere. Vivamus ut velit aliquet, mollis purus eget, iaculis nisl. Proin posuere malesuada ante. Proin auctor orci eros, ac molestie lorem dictum nec. Vestibulum sit amet erat est. Morbi luctus sed elit ac luctus. Proin blandit, enim vitae egestas posuere, neque elit ultricies dui, vel mattis nibh enim ac lorem. Maecenas molestie nisl sit amet velit dictum lobortis. Aliquam erat volutpat. 2 | 3 | Vivamus sagittis, diam in [vehicula](https://github.com/markdown-it/markdown-it) lobortis, sapien arcu mattis erat, vel aliquet sem urna et risus. Ut feugiat sapien vitae mi elementum laoreet. Suspendisse potenti. Aliquam erat nisl, aliquam pretium libero aliquet, sagittis eleifend nunc. In hac habitasse platea dictumst. Integer turpis augue, tincidunt dignissim mauris id, rhoncus dapibus purus. Maecenas et enim odio. Nullam massa metus, varius quis vehicula sed, pharetra mollis erat. In quis viverra velit. Vivamus placerat, est nec hendrerit varius, enim dui hendrerit magna, ut pulvinar nibh lorem vel lacus. Mauris a orci iaculis, hendrerit eros sed, gravida leo. In dictum mauris vel augue varius, ac ullamcorper nisl ornare. In eu posuere velit, ac fermentum arcu. Interdum et malesuada fames ac ante ipsum primis in faucibus. Nullam sed malesuada leo, at interdum elit. 4 | 5 | Nullam ut tincidunt nunc. [Pellentesque][1] metus lacus, commodo eget justo ut, rutrum varius nunc. Sed non rhoncus risus. Morbi sodales gravida pulvinar. Duis malesuada, odio volutpat elementum vulputate, massa magna scelerisque ante, et accumsan tellus nunc in sem. Donec mattis arcu et velit aliquet, non sagittis justo vestibulum. Suspendisse volutpat felis lectus, nec consequat ipsum mattis id. Donec dapibus vehicula facilisis. In tincidunt mi nisi, nec faucibus tortor euismod nec. Suspendisse ante ligula, aliquet vitae libero eu, vulputate dapibus libero. Sed bibendum, sapien at posuere interdum, libero est sollicitudin magna, ac gravida tellus purus eu ipsum. Proin ut quam arcu. 6 | 7 | Suspendisse potenti. Donec ante velit, ornare at augue quis, tristique laoreet sem. Etiam in ipsum elit. Nullam cursus dolor sit amet nulla feugiat tristique. Phasellus ac tellus tincidunt, imperdiet purus eget, ullamcorper ipsum. Cras eu tincidunt sem. Nullam sed dapibus magna. Lorem ipsum dolor sit amet, consectetur adipiscing elit. In id venenatis tortor. In consectetur sollicitudin pharetra. Etiam convallis nisi nunc, et aliquam turpis viverra sit amet. Maecenas faucibus sodales tortor. Suspendisse lobortis mi eu leo viverra volutpat. Pellentesque velit ante, vehicula sodales congue ut, elementum a urna. Cras tempor, ipsum eget luctus rhoncus, arcu ligula fermentum urna, vulputate pharetra enim enim non libero. 8 | 9 | Proin diam quam, elementum in eleifend id, elementum et metus. Cras in justo consequat justo semper ultrices. Sed dignissim lectus a ante mollis, nec vulputate ante molestie. Proin in porta nunc. Etiam pulvinar turpis sed velit porttitor, vel adipiscing velit fringilla. Cras ac tellus vitae purus pharetra tincidunt. Sed cursus aliquet aliquet. Cras eleifend commodo malesuada. In turpis turpis, ullamcorper ut tincidunt a, ullamcorper a nunc. Etiam luctus tellus ac dapibus gravida. Ut nec lacus laoreet neque ullamcorper volutpat. 10 | 11 | Nunc et leo erat. Aenean mattis ultrices lorem, eget adipiscing dolor ultricies eu. In hac habitasse platea dictumst. Vivamus cursus feugiat sapien quis aliquam. Mauris quam libero, porta vel volutpat ut, blandit a purus. Vivamus vestibulum dui vel tortor molestie, sit amet feugiat sem commodo. Nulla facilisi. Sed molestie arcu eget tellus vestibulum tristique. 12 | 13 | [1]: https://github.com/markdown-it 14 | -------------------------------------------------------------------------------- /wrappers/wrapper_ext.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | # 4 | # Example for using the shared library from python. 5 | # Will work with either python 2 or python 3. 6 | # Requires cmark-gfm and cmark-gfm-extensions libraries to be installed. 7 | # 8 | # This particular example uses the GitHub extensions from the gfm-extensions 9 | # library. EXTENSIONS specifies which to use, and the sample shows how to 10 | # connect them into a parser. 11 | # 12 | 13 | import sys 14 | import ctypes 15 | 16 | if sys.platform == 'darwin': 17 | libname = 'libcmark-gfm.dylib' 18 | extname = 'libcmark-gfm-extensions.dylib' 19 | elif sys.platform == 'win32': 20 | libname = 'cmark-gfm.dll' 21 | extname = 'cmark-gfm-extensions.dll' 22 | else: 23 | libname = 'libcmark-gfm.so' 24 | extname = 'libcmark-gfm-extensions.so' 25 | cmark = ctypes.CDLL(libname) 26 | cmark_ext = ctypes.CDLL(extname) 27 | 28 | # Options for the GFM rendering call 29 | OPTS = 0 # defaults 30 | 31 | # The GFM extensions that we want to use 32 | EXTENSIONS = ( 33 | 'autolink', 34 | 'table', 35 | 'strikethrough', 36 | 'tagfilter', 37 | ) 38 | 39 | # Use ctypes to access the functions in libcmark-gfm 40 | 41 | F_cmark_parser_new = cmark.cmark_parser_new 42 | F_cmark_parser_new.restype = ctypes.c_void_p 43 | F_cmark_parser_new.argtypes = (ctypes.c_int,) 44 | 45 | F_cmark_parser_feed = cmark.cmark_parser_feed 46 | F_cmark_parser_feed.restype = None 47 | F_cmark_parser_feed.argtypes = (ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t) 48 | 49 | F_cmark_parser_finish = cmark.cmark_parser_finish 50 | F_cmark_parser_finish.restype = ctypes.c_void_p 51 | F_cmark_parser_finish.argtypes = (ctypes.c_void_p,) 52 | 53 | F_cmark_parser_attach_syntax_extension = cmark.cmark_parser_attach_syntax_extension 54 | F_cmark_parser_attach_syntax_extension.restype = ctypes.c_int 55 | F_cmark_parser_attach_syntax_extension.argtypes = (ctypes.c_void_p, ctypes.c_void_p) 56 | 57 | F_cmark_parser_get_syntax_extensions = cmark.cmark_parser_get_syntax_extensions 58 | F_cmark_parser_get_syntax_extensions.restype = ctypes.c_void_p 59 | F_cmark_parser_get_syntax_extensions.argtypes = (ctypes.c_void_p,) 60 | 61 | F_cmark_parser_free = cmark.cmark_parser_free 62 | F_cmark_parser_free.restype = None 63 | F_cmark_parser_free.argtypes = (ctypes.c_void_p,) 64 | 65 | F_cmark_node_free = cmark.cmark_node_free 66 | F_cmark_node_free.restype = None 67 | F_cmark_node_free.argtypes = (ctypes.c_void_p,) 68 | 69 | F_cmark_find_syntax_extension = cmark.cmark_find_syntax_extension 70 | F_cmark_find_syntax_extension.restype = ctypes.c_void_p 71 | F_cmark_find_syntax_extension.argtypes = (ctypes.c_char_p,) 72 | 73 | F_cmark_render_html = cmark.cmark_render_html 74 | F_cmark_render_html.restype = ctypes.c_char_p 75 | F_cmark_render_html.argtypes = (ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p) 76 | 77 | 78 | # Set up the libcmark-gfm library and its extensions 79 | F_register = cmark_ext.cmark_gfm_core_extensions_ensure_registered 80 | F_register.restype = None 81 | F_register.argtypes = ( ) 82 | F_register() 83 | 84 | 85 | def md2html(text): 86 | "Use cmark-gfm to render the Markdown into an HTML fragment." 87 | 88 | parser = F_cmark_parser_new(OPTS) 89 | assert parser 90 | for name in EXTENSIONS: 91 | ext = F_cmark_find_syntax_extension(name) 92 | assert ext 93 | rv = F_cmark_parser_attach_syntax_extension(parser, ext) 94 | assert rv 95 | exts = F_cmark_parser_get_syntax_extensions(parser) 96 | 97 | F_cmark_parser_feed(parser, text, len(text)) 98 | doc = F_cmark_parser_finish(parser) 99 | assert doc 100 | 101 | output = F_cmark_render_html(doc, OPTS, exts) 102 | 103 | F_cmark_parser_free(parser) 104 | F_cmark_node_free(doc) 105 | 106 | return output 107 | 108 | 109 | sys.stdout.write(md2html(sys.stdin.read())) 110 | -------------------------------------------------------------------------------- /extensions/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(LIBRARY "libcmark-gfm-extensions") 2 | set(STATICLIBRARY "libcmark-gfm-extensions_static") 3 | set(LIBRARY_SOURCES 4 | core-extensions.c 5 | table.c 6 | strikethrough.c 7 | autolink.c 8 | tagfilter.c 9 | ext_scanners.c 10 | ext_scanners.re 11 | ext_scanners.h 12 | tasklist.c 13 | ) 14 | 15 | include_directories( 16 | ${PROJECT_SOURCE_DIR}/src 17 | ${PROJECT_BINARY_DIR}/src 18 | ) 19 | 20 | include_directories(. ${CMAKE_CURRENT_BINARY_DIR}) 21 | 22 | set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -pg") 23 | set(CMAKE_LINKER_PROFILE "${CMAKE_LINKER_FLAGS_RELEASE} -pg") 24 | 25 | if (CMARK_SHARED) 26 | add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES}) 27 | 28 | set_target_properties(${LIBRARY} PROPERTIES 29 | OUTPUT_NAME "cmark-gfm-extensions" 30 | DEFINE_SYMBOL "cmark-gfm" 31 | SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}.gfm.${PROJECT_VERSION_GFM} 32 | VERSION ${PROJECT_VERSION}) 33 | 34 | set_property(TARGET ${LIBRARY} 35 | APPEND PROPERTY MACOSX_RPATH true) 36 | 37 | # Avoid name clash between PROGRAM and LIBRARY pdb files. 38 | set_target_properties(${LIBRARY} PROPERTIES PDB_NAME cmark-gfm-extensions_dll) 39 | 40 | list(APPEND CMARK_INSTALL ${LIBRARY}) 41 | target_link_libraries(${LIBRARY} libcmark-gfm) 42 | 43 | endif() 44 | 45 | if (CMARK_STATIC) 46 | add_library(${STATICLIBRARY} STATIC ${LIBRARY_SOURCES}) 47 | 48 | set_target_properties(${STATICLIBRARY} PROPERTIES 49 | COMPILE_FLAGS "-DCMARK_GFM_STATIC_DEFINE -DCMARK_GFM_EXTENSIONS_STATIC_DEFINE" 50 | DEFINE_SYMBOL "cmark-gfm" 51 | POSITION_INDEPENDENT_CODE ON) 52 | 53 | if (MSVC) 54 | set_target_properties(${STATICLIBRARY} PROPERTIES 55 | OUTPUT_NAME "cmark-gfm-extensions_static" 56 | VERSION ${PROJECT_VERSION}) 57 | else() 58 | set_target_properties(${STATICLIBRARY} PROPERTIES 59 | OUTPUT_NAME "cmark-gfm-extensions" 60 | VERSION ${PROJECT_VERSION}) 61 | endif(MSVC) 62 | 63 | list(APPEND CMARK_INSTALL ${STATICLIBRARY}) 64 | endif() 65 | 66 | set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON) 67 | 68 | include (InstallRequiredSystemLibraries) 69 | install(TARGETS ${CMARK_INSTALL} 70 | EXPORT cmark-gfm-extensions 71 | RUNTIME DESTINATION bin 72 | LIBRARY DESTINATION lib${LIB_SUFFIX} 73 | ARCHIVE DESTINATION lib${LIB_SUFFIX} 74 | ) 75 | 76 | if (CMARK_SHARED OR CMARK_STATIC) 77 | install(FILES 78 | cmark-gfm-core-extensions.h 79 | DESTINATION include 80 | ) 81 | 82 | install(EXPORT cmark-gfm-extensions DESTINATION lib${LIB_SUFFIX}/cmake-gfm-extensions) 83 | endif() 84 | 85 | # Feature tests 86 | include(CheckIncludeFile) 87 | include(CheckCSourceCompiles) 88 | include(CheckCSourceRuns) 89 | include(CheckSymbolExists) 90 | CHECK_INCLUDE_FILE(stdbool.h HAVE_STDBOOL_H) 91 | CHECK_C_SOURCE_COMPILES( 92 | "int main() { __builtin_expect(0,0); return 0; }" 93 | HAVE___BUILTIN_EXPECT) 94 | CHECK_C_SOURCE_COMPILES(" 95 | int f(void) __attribute__ (()); 96 | int main() { return 0; } 97 | " HAVE___ATTRIBUTE__) 98 | 99 | # Always compile with warnings 100 | if(MSVC) 101 | # Force to always compile with W4 102 | if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") 103 | string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") 104 | else() 105 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4") 106 | endif() 107 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX /wd4706 /wd4204 /wd4221 /wd4100 /D_CRT_SECURE_NO_WARNINGS") 108 | elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") 109 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wno-unused-parameter -std=c99 -pedantic") 110 | endif() 111 | 112 | # Compile as C++ under MSVC older than 12.0 113 | if(MSVC AND MSVC_VERSION LESS 1800) 114 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /TP") 115 | endif() 116 | 117 | if(CMAKE_BUILD_TYPE STREQUAL "Ubsan") 118 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined") 119 | endif() 120 | -------------------------------------------------------------------------------- /src/chunk.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_CHUNK_H 2 | #define CMARK_CHUNK_H 3 | 4 | #include <string.h> 5 | #include <stdlib.h> 6 | #include <assert.h> 7 | #include "cmark-gfm.h" 8 | #include "buffer.h" 9 | #include "cmark_ctype.h" 10 | 11 | #define CMARK_CHUNK_EMPTY \ 12 | { NULL, 0, 0 } 13 | 14 | typedef struct cmark_chunk { 15 | unsigned char *data; 16 | bufsize_t len; 17 | bufsize_t alloc; // also implies a NULL-terminated string 18 | } cmark_chunk; 19 | 20 | static CMARK_INLINE void cmark_chunk_free(cmark_mem *mem, cmark_chunk *c) { 21 | if (c->alloc) 22 | mem->free(c->data); 23 | 24 | c->data = NULL; 25 | c->alloc = 0; 26 | c->len = 0; 27 | } 28 | 29 | static CMARK_INLINE void cmark_chunk_ltrim(cmark_chunk *c) { 30 | assert(!c->alloc); 31 | 32 | while (c->len && cmark_isspace(c->data[0])) { 33 | c->data++; 34 | c->len--; 35 | } 36 | } 37 | 38 | static CMARK_INLINE void cmark_chunk_rtrim(cmark_chunk *c) { 39 | assert(!c->alloc); 40 | 41 | while (c->len > 0) { 42 | if (!cmark_isspace(c->data[c->len - 1])) 43 | break; 44 | 45 | c->len--; 46 | } 47 | } 48 | 49 | static CMARK_INLINE void cmark_chunk_trim(cmark_chunk *c) { 50 | cmark_chunk_ltrim(c); 51 | cmark_chunk_rtrim(c); 52 | } 53 | 54 | static CMARK_INLINE bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c, 55 | bufsize_t offset) { 56 | const unsigned char *p = 57 | (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); 58 | return p ? (bufsize_t)(p - ch->data) : ch->len; 59 | } 60 | 61 | static CMARK_INLINE const char *cmark_chunk_to_cstr(cmark_mem *mem, 62 | cmark_chunk *c) { 63 | unsigned char *str; 64 | 65 | if (c->alloc) { 66 | return (char *)c->data; 67 | } 68 | str = (unsigned char *)mem->calloc(c->len + 1, 1); 69 | if (c->len > 0) { 70 | memcpy(str, c->data, c->len); 71 | } 72 | str[c->len] = 0; 73 | c->data = str; 74 | c->alloc = 1; 75 | 76 | return (char *)str; 77 | } 78 | 79 | static CMARK_INLINE void cmark_chunk_set_cstr(cmark_mem *mem, cmark_chunk *c, 80 | const char *str) { 81 | unsigned char *old = c->alloc ? c->data : NULL; 82 | if (str == NULL) { 83 | c->len = 0; 84 | c->data = NULL; 85 | c->alloc = 0; 86 | } else { 87 | c->len = (bufsize_t)strlen(str); 88 | c->data = (unsigned char *)mem->calloc(c->len + 1, 1); 89 | c->alloc = 1; 90 | memcpy(c->data, str, c->len + 1); 91 | } 92 | if (old != NULL) { 93 | mem->free(old); 94 | } 95 | } 96 | 97 | static CMARK_INLINE cmark_chunk cmark_chunk_literal(const char *data) { 98 | bufsize_t len = data ? (bufsize_t)strlen(data) : 0; 99 | cmark_chunk c = {(unsigned char *)data, len, 0}; 100 | return c; 101 | } 102 | 103 | static CMARK_INLINE cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, 104 | bufsize_t pos, bufsize_t len) { 105 | cmark_chunk c = {ch->data + pos, len, 0}; 106 | return c; 107 | } 108 | 109 | static CMARK_INLINE cmark_chunk cmark_chunk_buf_detach(cmark_strbuf *buf) { 110 | cmark_chunk c; 111 | 112 | c.len = buf->size; 113 | c.data = cmark_strbuf_detach(buf); 114 | c.alloc = 1; 115 | 116 | return c; 117 | } 118 | 119 | /* trim_new variants are to be used when the source chunk may or may not be 120 | * allocated; forces a newly allocated chunk. */ 121 | static CMARK_INLINE cmark_chunk cmark_chunk_ltrim_new(cmark_mem *mem, cmark_chunk *c) { 122 | cmark_chunk r = cmark_chunk_dup(c, 0, c->len); 123 | cmark_chunk_ltrim(&r); 124 | cmark_chunk_to_cstr(mem, &r); 125 | return r; 126 | } 127 | 128 | static CMARK_INLINE cmark_chunk cmark_chunk_rtrim_new(cmark_mem *mem, cmark_chunk *c) { 129 | cmark_chunk r = cmark_chunk_dup(c, 0, c->len); 130 | cmark_chunk_rtrim(&r); 131 | cmark_chunk_to_cstr(mem, &r); 132 | return r; 133 | } 134 | 135 | #endif 136 | -------------------------------------------------------------------------------- /src/houdini_html_u.c: -------------------------------------------------------------------------------- 1 | #include <assert.h> 2 | #include <stdio.h> 3 | #include <string.h> 4 | 5 | #include "buffer.h" 6 | #include "houdini.h" 7 | #include "utf8.h" 8 | #include "entities.inc" 9 | 10 | /* Binary tree lookup code for entities added by JGM */ 11 | 12 | static const unsigned char *S_lookup(int i, int low, int hi, 13 | const unsigned char *s, int len) { 14 | int j; 15 | int cmp = 16 | strncmp((const char *)s, (const char *)cmark_entities[i].entity, len); 17 | if (cmp == 0 && cmark_entities[i].entity[len] == 0) { 18 | return (const unsigned char *)cmark_entities[i].bytes; 19 | } else if (cmp <= 0 && i > low) { 20 | j = i - ((i - low) / 2); 21 | if (j == i) 22 | j -= 1; 23 | return S_lookup(j, low, i - 1, s, len); 24 | } else if (cmp > 0 && i < hi) { 25 | j = i + ((hi - i) / 2); 26 | if (j == i) 27 | j += 1; 28 | return S_lookup(j, i + 1, hi, s, len); 29 | } else { 30 | return NULL; 31 | } 32 | } 33 | 34 | static const unsigned char *S_lookup_entity(const unsigned char *s, int len) { 35 | return S_lookup(CMARK_NUM_ENTITIES / 2, 0, CMARK_NUM_ENTITIES - 1, s, len); 36 | } 37 | 38 | bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, 39 | bufsize_t size) { 40 | bufsize_t i = 0; 41 | 42 | if (size >= 3 && src[0] == '#') { 43 | int codepoint = 0; 44 | int num_digits = 0; 45 | 46 | if (_isdigit(src[1])) { 47 | for (i = 1; i < size && _isdigit(src[i]); ++i) { 48 | codepoint = (codepoint * 10) + (src[i] - '0'); 49 | 50 | if (codepoint >= 0x110000) { 51 | // Keep counting digits but 52 | // avoid integer overflow. 53 | codepoint = 0x110000; 54 | } 55 | } 56 | 57 | num_digits = i - 1; 58 | } 59 | 60 | else if (src[1] == 'x' || src[1] == 'X') { 61 | for (i = 2; i < size && _isxdigit(src[i]); ++i) { 62 | codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9); 63 | 64 | if (codepoint >= 0x110000) { 65 | // Keep counting digits but 66 | // avoid integer overflow. 67 | codepoint = 0x110000; 68 | } 69 | } 70 | 71 | num_digits = i - 2; 72 | } 73 | 74 | if (num_digits >= 1 && num_digits <= 8 && i < size && src[i] == ';') { 75 | if (codepoint == 0 || (codepoint >= 0xD800 && codepoint < 0xE000) || 76 | codepoint >= 0x110000) { 77 | codepoint = 0xFFFD; 78 | } 79 | cmark_utf8proc_encode_char(codepoint, ob); 80 | return i + 1; 81 | } 82 | } 83 | 84 | else { 85 | if (size > CMARK_ENTITY_MAX_LENGTH) 86 | size = CMARK_ENTITY_MAX_LENGTH; 87 | 88 | for (i = CMARK_ENTITY_MIN_LENGTH; i < size; ++i) { 89 | if (src[i] == ' ') 90 | break; 91 | 92 | if (src[i] == ';') { 93 | const unsigned char *entity = S_lookup_entity(src, i); 94 | 95 | if (entity != NULL) { 96 | cmark_strbuf_puts(ob, (const char *)entity); 97 | return i + 1; 98 | } 99 | 100 | break; 101 | } 102 | } 103 | } 104 | 105 | return 0; 106 | } 107 | 108 | int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, 109 | bufsize_t size) { 110 | bufsize_t i = 0, org, ent; 111 | 112 | while (i < size) { 113 | org = i; 114 | while (i < size && src[i] != '&') 115 | i++; 116 | 117 | if (likely(i > org)) { 118 | if (unlikely(org == 0)) { 119 | if (i >= size) 120 | return 0; 121 | 122 | cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size)); 123 | } 124 | 125 | cmark_strbuf_put(ob, src + org, i - org); 126 | } 127 | 128 | /* escaping */ 129 | if (i >= size) 130 | break; 131 | 132 | i++; 133 | 134 | ent = houdini_unescape_ent(ob, src + i, size - i); 135 | i += ent; 136 | 137 | /* not really an entity */ 138 | if (ent == 0) 139 | cmark_strbuf_putc(ob, '&'); 140 | } 141 | 142 | return 1; 143 | } 144 | 145 | void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, 146 | bufsize_t size) { 147 | if (!houdini_unescape_html(ob, src, size)) 148 | cmark_strbuf_put(ob, src, size); 149 | } 150 | -------------------------------------------------------------------------------- /fuzz/fuzz_quadratic_brackets.c: -------------------------------------------------------------------------------- 1 | #include <stdint.h> 2 | #include <stdlib.h> 3 | #include <string.h> 4 | #include "cmark-gfm.h" 5 | #include "cmark-gfm-core-extensions.h" 6 | #include <sys/types.h> 7 | #include <sys/stat.h> 8 | #include <fcntl.h> 9 | #include <unistd.h> 10 | 11 | const char *extension_names[] = { 12 | "autolink", 13 | "strikethrough", 14 | "table", 15 | "tagfilter", 16 | NULL, 17 | }; 18 | 19 | int LLVMFuzzerInitialize(int *argc, char ***argv) { 20 | cmark_gfm_core_extensions_ensure_registered(); 21 | return 0; 22 | } 23 | 24 | int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 25 | struct __attribute__((packed)) { 26 | int options; 27 | int width; 28 | uint8_t startlen; 29 | uint8_t openlen; 30 | uint8_t middlelen; 31 | uint8_t closelen; 32 | } fuzz_config; 33 | 34 | if (size >= sizeof(fuzz_config)) { 35 | /* The beginning of `data` is treated as fuzzer configuration */ 36 | memcpy(&fuzz_config, data, sizeof(fuzz_config)); 37 | 38 | /* Test options that are used by GitHub. */ 39 | fuzz_config.options = CMARK_OPT_UNSAFE | CMARK_OPT_FOOTNOTES | CMARK_OPT_GITHUB_PRE_LANG | CMARK_OPT_HARDBREAKS; 40 | fuzz_config.openlen = fuzz_config.openlen & 0x7; 41 | fuzz_config.middlelen = fuzz_config.middlelen & 0x7; 42 | fuzz_config.closelen = fuzz_config.closelen & 0x7; 43 | 44 | /* Remainder of input is the markdown */ 45 | const char *markdown0 = (const char *)(data + sizeof(fuzz_config)); 46 | const size_t markdown_size0 = size - sizeof(fuzz_config); 47 | char markdown[0x80000]; 48 | if (markdown_size0 <= sizeof(markdown)) { 49 | size_t markdown_size = 0; 50 | const size_t componentslen = fuzz_config.startlen + fuzz_config.openlen + fuzz_config.middlelen + fuzz_config.closelen; 51 | if (componentslen <= markdown_size0) { 52 | size_t offset = 0; 53 | const size_t endlen = markdown_size0 - componentslen; 54 | memcpy(&markdown[markdown_size], &markdown0[offset], fuzz_config.startlen); 55 | markdown_size += fuzz_config.startlen; 56 | offset += fuzz_config.startlen; 57 | 58 | if (0 < fuzz_config.openlen) { 59 | while (markdown_size + fuzz_config.openlen <= sizeof(markdown)/2) { 60 | memcpy(&markdown[markdown_size], &markdown0[offset], 61 | fuzz_config.openlen); 62 | markdown_size += fuzz_config.openlen; 63 | } 64 | offset += fuzz_config.openlen; 65 | } 66 | memcpy(&markdown[markdown_size], &markdown0[offset], 67 | fuzz_config.middlelen); 68 | markdown_size += fuzz_config.middlelen; 69 | offset += fuzz_config.middlelen; 70 | if (0 < fuzz_config.closelen) { 71 | while (markdown_size + fuzz_config.closelen + endlen <= sizeof(markdown)) { 72 | memcpy(&markdown[markdown_size], &markdown0[offset], 73 | fuzz_config.closelen); 74 | markdown_size += fuzz_config.closelen; 75 | } 76 | offset += fuzz_config.closelen; 77 | } 78 | if (markdown_size + endlen <= sizeof(markdown)) { 79 | memcpy(&markdown[markdown_size], &markdown0[offset], 80 | endlen); 81 | markdown_size += endlen; 82 | } 83 | } else { 84 | markdown_size = markdown_size0; 85 | memcpy(markdown, markdown0, markdown_size); 86 | } 87 | 88 | cmark_parser *parser = cmark_parser_new(fuzz_config.options); 89 | 90 | for (const char **it = extension_names; *it; ++it) { 91 | const char *extension_name = *it; 92 | cmark_syntax_extension *syntax_extension = cmark_find_syntax_extension(extension_name); 93 | if (!syntax_extension) { 94 | fprintf(stderr, "%s is not a valid syntax extension\n", extension_name); 95 | abort(); 96 | } 97 | cmark_parser_attach_syntax_extension(parser, syntax_extension); 98 | } 99 | 100 | cmark_parser_feed(parser, markdown, markdown_size); 101 | cmark_node *doc = cmark_parser_finish(parser); 102 | 103 | free(cmark_render_html(doc, fuzz_config.options, NULL)); 104 | 105 | cmark_node_free(doc); 106 | cmark_parser_free(parser); 107 | } 108 | } 109 | return 0; 110 | } 111 | -------------------------------------------------------------------------------- /test/cmark.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | 4 | from ctypes import CDLL, c_char_p, c_size_t, c_int, c_void_p 5 | from subprocess import * 6 | import platform 7 | import os 8 | 9 | def pipe_through_prog(prog, text): 10 | p1 = Popen(prog.split(), stdout=PIPE, stdin=PIPE, stderr=PIPE) 11 | [result, err] = p1.communicate(input=text.encode('utf-8')) 12 | return [p1.returncode, result.decode('utf-8'), err] 13 | 14 | def parse(lib, extlib, text, extensions): 15 | cmark_gfm_core_extensions_ensure_registered = extlib.cmark_gfm_core_extensions_ensure_registered 16 | 17 | find_syntax_extension = lib.cmark_find_syntax_extension 18 | find_syntax_extension.restype = c_void_p 19 | find_syntax_extension.argtypes = [c_char_p] 20 | 21 | parser_attach_syntax_extension = lib.cmark_parser_attach_syntax_extension 22 | parser_attach_syntax_extension.argtypes = [c_void_p, c_void_p] 23 | 24 | parser_new = lib.cmark_parser_new 25 | parser_new.restype = c_void_p 26 | parser_new.argtypes = [c_int] 27 | 28 | parser_feed = lib.cmark_parser_feed 29 | parser_feed.argtypes = [c_void_p, c_char_p, c_int] 30 | 31 | parser_finish = lib.cmark_parser_finish 32 | parser_finish.restype = c_void_p 33 | parser_finish.argtypes = [c_void_p] 34 | 35 | cmark_gfm_core_extensions_ensure_registered() 36 | 37 | parser = parser_new(0) 38 | for e in set(extensions): 39 | ext = find_syntax_extension(bytes(e, 'utf-8')) 40 | if not ext: 41 | raise Exception("Extension not found: '{}'".format(e)) 42 | parser_attach_syntax_extension(parser, ext) 43 | 44 | textbytes = text.encode('utf-8') 45 | textlen = len(textbytes) 46 | parser_feed(parser, textbytes, textlen) 47 | 48 | return [parser_finish(parser), parser] 49 | 50 | def to_html(lib, extlib, text, extensions): 51 | document, parser = parse(lib, extlib, text, extensions) 52 | parser_get_syntax_extensions = lib.cmark_parser_get_syntax_extensions 53 | parser_get_syntax_extensions.restype = c_void_p 54 | parser_get_syntax_extensions.argtypes = [c_void_p] 55 | syntax_extensions = parser_get_syntax_extensions(parser) 56 | 57 | render_html = lib.cmark_render_html 58 | render_html.restype = c_char_p 59 | render_html.argtypes = [c_void_p, c_int, c_void_p] 60 | # 1 << 17 == CMARK_OPT_UNSAFE 61 | result = render_html(document, 1 << 17, syntax_extensions).decode('utf-8') 62 | return [0, result, ''] 63 | 64 | def to_commonmark(lib, extlib, text, extensions): 65 | document, _ = parse(lib, extlib, text, extensions) 66 | 67 | render_commonmark = lib.cmark_render_commonmark 68 | render_commonmark.restype = c_char_p 69 | render_commonmark.argtypes = [c_void_p, c_int, c_int] 70 | result = render_commonmark(document, 0, 0).decode('utf-8') 71 | return [0, result, ''] 72 | 73 | class CMark: 74 | def __init__(self, prog=None, library_dir=None, extensions=None): 75 | self.prog = prog 76 | self.extensions = [] 77 | if extensions: 78 | self.extensions = extensions.split() 79 | 80 | if prog: 81 | prog += ' --unsafe' 82 | extsfun = lambda exts: ''.join([' -e ' + e for e in set(exts)]) 83 | self.to_html = lambda x, exts=[]: pipe_through_prog(prog + extsfun(exts + self.extensions), x) 84 | self.to_commonmark = lambda x, exts=[]: pipe_through_prog(prog + ' -t commonmark' + extsfun(exts + self.extensions), x) 85 | else: 86 | sysname = platform.system() 87 | if sysname == 'Darwin': 88 | libnames = [ ["lib", ".dylib" ] ] 89 | elif sysname == 'Windows': 90 | libnames = [ ["", ".dll"], ["lib", ".dll"] ] 91 | else: 92 | libnames = [ ["lib", ".so"] ] 93 | if not library_dir: 94 | library_dir = os.path.join("..", "build", "src") 95 | for prefix, suffix in libnames: 96 | candidate = os.path.join(library_dir, prefix + "cmark-gfm" + suffix) 97 | if os.path.isfile(candidate): 98 | libpath = candidate 99 | break 100 | cmark = CDLL(libpath) 101 | extlib = CDLL(os.path.join( 102 | library_dir, "..", "extensions", prefix + "cmark-gfm-extensions" + suffix)) 103 | self.to_html = lambda x, exts=[]: to_html(cmark, extlib, x, exts + self.extensions) 104 | self.to_commonmark = lambda x, exts=[]: to_commonmark(cmark, extlib, x, exts + self.extensions) 105 | 106 | -------------------------------------------------------------------------------- /test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # To get verbose output: cmake --build build --target "test" -- ARGS='-V' 2 | 3 | # By default, we run the spec tests only if python3 is available. 4 | # To require the spec tests, compile with -DSPEC_TESTS=1 5 | 6 | if (SPEC_TESTS) 7 | find_package(PythonInterp 3 REQUIRED) 8 | else(SPEC_TESTS) 9 | find_package(PythonInterp 3) 10 | endif(SPEC_TESTS) 11 | 12 | if (CMARK_SHARED OR CMARK_STATIC) 13 | add_test(NAME api_test COMMAND api_test) 14 | endif() 15 | 16 | if (WIN32) 17 | file(TO_NATIVE_PATH ${CMAKE_BINARY_DIR}/src WIN_SRC_DLL_DIR) 18 | file(TO_NATIVE_PATH ${CMAKE_BINARY_DIR}/extensions WIN_EXTENSIONS_DLL_DIR) 19 | set(NEWPATH "${WIN_SRC_DLL_DIR};${WIN_EXTENSIONS_DLL_DIR};$ENV{PATH}") 20 | string(REPLACE ";" "\\;" NEWPATH "${NEWPATH}") 21 | set_tests_properties(api_test PROPERTIES ENVIRONMENT "PATH=${NEWPATH}") 22 | set(ROUNDTRIP "${CMAKE_CURRENT_SOURCE_DIR}/roundtrip.bat") 23 | else(WIN32) 24 | set(ROUNDTRIP "${CMAKE_CURRENT_SOURCE_DIR}/roundtrip.sh") 25 | endif(WIN32) 26 | 27 | IF (PYTHONINTERP_FOUND) 28 | 29 | add_test(html_normalization 30 | ${PYTHON_EXECUTABLE} "-m" "doctest" 31 | "${CMAKE_CURRENT_SOURCE_DIR}/normalize.py" 32 | ) 33 | 34 | if (CMARK_SHARED) 35 | add_test(spectest_library 36 | ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/spec_tests.py" "--no-normalize" "--spec" 37 | "${CMAKE_CURRENT_SOURCE_DIR}/spec.txt" "--library-dir" "${CMAKE_CURRENT_BINARY_DIR}/../src" 38 | ) 39 | 40 | add_test(pathological_tests_library 41 | ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/pathological_tests.py" 42 | "--library-dir" "${CMAKE_CURRENT_BINARY_DIR}/../src" 43 | ) 44 | 45 | add_test(roundtriptest_library 46 | ${PYTHON_EXECUTABLE} 47 | "${CMAKE_CURRENT_SOURCE_DIR}/roundtrip_tests.py" 48 | "--spec" "${CMAKE_CURRENT_SOURCE_DIR}/spec.txt" 49 | "--library-dir" "${CMAKE_CURRENT_BINARY_DIR}/../src" 50 | ) 51 | 52 | add_test(entity_library 53 | ${PYTHON_EXECUTABLE} 54 | "${CMAKE_CURRENT_SOURCE_DIR}/entity_tests.py" 55 | "--library-dir" "${CMAKE_CURRENT_BINARY_DIR}/../src" 56 | ) 57 | endif() 58 | 59 | add_test(spectest_executable 60 | ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/spec_tests.py" "--no-normalize" "--spec" "${CMAKE_CURRENT_SOURCE_DIR}/spec.txt" "--program" "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark-gfm" 61 | ) 62 | 63 | add_test(smartpuncttest_executable 64 | ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/spec_tests.py" "--no-normalize" "--spec" "${CMAKE_CURRENT_SOURCE_DIR}/smart_punct.txt" "--program" "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark-gfm --smart" 65 | ) 66 | 67 | add_test(extensions_executable 68 | ${PYTHON_EXECUTABLE} 69 | "${CMAKE_CURRENT_SOURCE_DIR}/spec_tests.py" 70 | "--no-normalize" 71 | "--spec" "${CMAKE_CURRENT_SOURCE_DIR}/extensions.txt" 72 | "--program" "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark-gfm" 73 | "--extensions" "table strikethrough autolink tagfilter footnotes tasklist" 74 | ) 75 | 76 | add_test(roundtrip_extensions_executable 77 | ${PYTHON_EXECUTABLE} 78 | "${CMAKE_CURRENT_SOURCE_DIR}/roundtrip_tests.py" 79 | "--spec" "${CMAKE_CURRENT_SOURCE_DIR}/extensions.txt" 80 | "--program" "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark-gfm" 81 | "--extensions" "table strikethrough autolink tagfilter footnotes tasklist" 82 | ) 83 | 84 | add_test(option_table_prefer_style_attributes 85 | ${PYTHON_EXECUTABLE} 86 | "${CMAKE_CURRENT_SOURCE_DIR}/roundtrip_tests.py" 87 | "--spec" "${CMAKE_CURRENT_SOURCE_DIR}/extensions-table-prefer-style-attributes.txt" 88 | "--program" "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark-gfm --table-prefer-style-attributes" 89 | "--extensions" "table strikethrough autolink tagfilter footnotes tasklist" 90 | ) 91 | 92 | add_test(option_full_info_string 93 | ${PYTHON_EXECUTABLE} 94 | "${CMAKE_CURRENT_SOURCE_DIR}/roundtrip_tests.py" 95 | "--spec" "${CMAKE_CURRENT_SOURCE_DIR}/extensions-full-info-string.txt" 96 | "--program" "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark-gfm --full-info-string" 97 | ) 98 | 99 | add_test(regressiontest_executable 100 | ${PYTHON_EXECUTABLE} 101 | "${CMAKE_CURRENT_SOURCE_DIR}/spec_tests.py" "--no-normalize" "--spec" 102 | "${CMAKE_CURRENT_SOURCE_DIR}/regression.txt" "--program" 103 | "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark-gfm" 104 | ) 105 | 106 | 107 | ELSE(PYTHONINTERP_FOUND) 108 | 109 | message("\n*** A python 3 interpreter is required to run the spec tests.\n") 110 | add_test(skipping_spectests 111 | echo "Skipping spec tests, because no python 3 interpreter is available.") 112 | 113 | ENDIF(PYTHONINTERP_FOUND) 114 | 115 | -------------------------------------------------------------------------------- /src/node.h: -------------------------------------------------------------------------------- 1 | #ifndef CMARK_NODE_H 2 | #define CMARK_NODE_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #include <stdio.h> 9 | #include <stdint.h> 10 | 11 | #include "cmark-gfm.h" 12 | #include "cmark-gfm-extension_api.h" 13 | #include "buffer.h" 14 | #include "chunk.h" 15 | 16 | typedef struct { 17 | cmark_list_type list_type; 18 | int marker_offset; 19 | int padding; 20 | int start; 21 | cmark_delim_type delimiter; 22 | unsigned char bullet_char; 23 | bool tight; 24 | bool checked; // For task list extension 25 | } cmark_list; 26 | 27 | typedef struct { 28 | cmark_chunk info; 29 | cmark_chunk literal; 30 | uint8_t fence_length; 31 | uint8_t fence_offset; 32 | unsigned char fence_char; 33 | int8_t fenced; 34 | } cmark_code; 35 | 36 | typedef struct { 37 | int level; 38 | bool setext; 39 | } cmark_heading; 40 | 41 | typedef struct { 42 | cmark_chunk url; 43 | cmark_chunk title; 44 | } cmark_link; 45 | 46 | typedef struct { 47 | cmark_chunk on_enter; 48 | cmark_chunk on_exit; 49 | } cmark_custom; 50 | 51 | enum cmark_node__internal_flags { 52 | CMARK_NODE__OPEN = (1 << 0), 53 | CMARK_NODE__LAST_LINE_BLANK = (1 << 1), 54 | CMARK_NODE__LAST_LINE_CHECKED = (1 << 2), 55 | 56 | // Extensions can register custom flags by calling `cmark_register_node_flag`. 57 | // This is the starting value for the custom flags. 58 | CMARK_NODE__REGISTER_FIRST = (1 << 3), 59 | }; 60 | 61 | typedef uint16_t cmark_node_internal_flags; 62 | 63 | struct cmark_node { 64 | cmark_strbuf content; 65 | 66 | struct cmark_node *next; 67 | struct cmark_node *prev; 68 | struct cmark_node *parent; 69 | struct cmark_node *first_child; 70 | struct cmark_node *last_child; 71 | 72 | void *user_data; 73 | cmark_free_func user_data_free_func; 74 | 75 | int start_line; 76 | int start_column; 77 | int end_line; 78 | int end_column; 79 | int internal_offset; 80 | uint16_t type; 81 | cmark_node_internal_flags flags; 82 | 83 | cmark_syntax_extension *extension; 84 | 85 | /** 86 | * Used during cmark_render() to cache the most recent non-NULL 87 | * extension, if you go up the parent chain like this: 88 | * 89 | * node->parent->...parent->extension 90 | */ 91 | cmark_syntax_extension *ancestor_extension; 92 | 93 | union { 94 | int ref_ix; 95 | int def_count; 96 | } footnote; 97 | 98 | cmark_node *parent_footnote_def; 99 | 100 | union { 101 | cmark_chunk literal; 102 | cmark_list list; 103 | cmark_code code; 104 | cmark_heading heading; 105 | cmark_link link; 106 | cmark_custom custom; 107 | int html_block_type; 108 | int cell_index; // For keeping track of TABLE_CELL table alignments 109 | void *opaque; 110 | } as; 111 | }; 112 | 113 | /** 114 | * Syntax extensions can use this function to register a custom node 115 | * flag. The flags are stored in the `flags` field of the `cmark_node` 116 | * struct. The `flags` parameter should be the address of a global variable 117 | * which will store the flag value. 118 | */ 119 | CMARK_GFM_EXPORT 120 | void cmark_register_node_flag(cmark_node_internal_flags *flags); 121 | 122 | /** 123 | * DEPRECATED. 124 | * 125 | * This function was added in cmark-gfm version 0.29.0.gfm.7, and was 126 | * required to be called at program start time, which caused 127 | * backwards-compatibility issues in applications that use cmark-gfm as a 128 | * library. It is now a no-op. 129 | */ 130 | CMARK_GFM_EXPORT 131 | void cmark_init_standard_node_flags(void); 132 | 133 | static CMARK_INLINE cmark_mem *cmark_node_mem(cmark_node *node) { 134 | return node->content.mem; 135 | } 136 | CMARK_GFM_EXPORT int cmark_node_check(cmark_node *node, FILE *out); 137 | 138 | static CMARK_INLINE bool CMARK_NODE_TYPE_BLOCK_P(cmark_node_type node_type) { 139 | return (node_type & CMARK_NODE_TYPE_MASK) == CMARK_NODE_TYPE_BLOCK; 140 | } 141 | 142 | static CMARK_INLINE bool CMARK_NODE_BLOCK_P(cmark_node *node) { 143 | return node != NULL && CMARK_NODE_TYPE_BLOCK_P((cmark_node_type) node->type); 144 | } 145 | 146 | static CMARK_INLINE bool CMARK_NODE_TYPE_INLINE_P(cmark_node_type node_type) { 147 | return (node_type & CMARK_NODE_TYPE_MASK) == CMARK_NODE_TYPE_INLINE; 148 | } 149 | 150 | static CMARK_INLINE bool CMARK_NODE_INLINE_P(cmark_node *node) { 151 | return node != NULL && CMARK_NODE_TYPE_INLINE_P((cmark_node_type) node->type); 152 | } 153 | 154 | CMARK_GFM_EXPORT bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type); 155 | 156 | /** 157 | * Enable (or disable) extra safety checks. These extra checks cause 158 | * extra performance overhead (in some cases quadratic), so they are only 159 | * intended to be used during testing. 160 | */ 161 | CMARK_GFM_EXPORT void cmark_enable_safety_checks(bool enable); 162 | 163 | #ifdef __cplusplus 164 | } 165 | #endif 166 | 167 | #endif 168 | -------------------------------------------------------------------------------- /test/smart_punct.txt: -------------------------------------------------------------------------------- 1 | ## Smart punctuation 2 | 3 | Open quotes are matched with closed quotes. 4 | The same method is used for matching openers and closers 5 | as is used in emphasis parsing: 6 | 7 | ```````````````````````````````` example 8 | "Hello," said the spider. 9 | "'Shelob' is my name." 10 | . 11 | <p>“Hello,” said the spider. 12 | “‘Shelob’ is my name.”</p> 13 | ```````````````````````````````` 14 | 15 | ```````````````````````````````` example 16 | 'A', 'B', and 'C' are letters. 17 | . 18 | <p>‘A’, ‘B’, and ‘C’ are letters.</p> 19 | ```````````````````````````````` 20 | 21 | ```````````````````````````````` example 22 | 'Oak,' 'elm,' and 'beech' are names of trees. 23 | So is 'pine.' 24 | . 25 | <p>‘Oak,’ ‘elm,’ and ‘beech’ are names of trees. 26 | So is ‘pine.’</p> 27 | ```````````````````````````````` 28 | 29 | ```````````````````````````````` example 30 | 'He said, "I want to go."' 31 | . 32 | <p>‘He said, “I want to go.”’</p> 33 | ```````````````````````````````` 34 | 35 | A single quote that isn't an open quote matched 36 | with a close quote will be treated as an 37 | apostrophe: 38 | 39 | ```````````````````````````````` example 40 | Were you alive in the 70's? 41 | . 42 | <p>Were you alive in the 70’s?</p> 43 | ```````````````````````````````` 44 | 45 | ```````````````````````````````` example 46 | Here is some quoted '`code`' and a "[quoted link](url)". 47 | . 48 | <p>Here is some quoted ‘<code>code</code>’ and a “<a href="url">quoted link</a>”.</p> 49 | ```````````````````````````````` 50 | 51 | Here the first `'` is treated as an apostrophe, not 52 | an open quote, because the final single quote is matched 53 | by the single quote before `jolly`: 54 | 55 | ```````````````````````````````` example 56 | 'tis the season to be 'jolly' 57 | . 58 | <p>’tis the season to be ‘jolly’</p> 59 | ```````````````````````````````` 60 | 61 | Multiple apostrophes should not be marked as open/closing quotes. 62 | 63 | ```````````````````````````````` example 64 | 'We'll use Jane's boat and John's truck,' Jenna said. 65 | . 66 | <p>‘We’ll use Jane’s boat and John’s truck,’ Jenna said.</p> 67 | ```````````````````````````````` 68 | 69 | An unmatched double quote will be interpreted as a 70 | left double quote, to facilitate this style: 71 | 72 | ```````````````````````````````` example 73 | "A paragraph with no closing quote. 74 | 75 | "Second paragraph by same speaker, in fiction." 76 | . 77 | <p>“A paragraph with no closing quote.</p> 78 | <p>“Second paragraph by same speaker, in fiction.”</p> 79 | ```````````````````````````````` 80 | 81 | A quote following a `]` or `)` character cannot 82 | be an open quote: 83 | 84 | ```````````````````````````````` example 85 | [a]'s b' 86 | . 87 | <p>[a]’s b’</p> 88 | ```````````````````````````````` 89 | 90 | Quotes that are escaped come out as literal straight 91 | quotes: 92 | 93 | ```````````````````````````````` example 94 | \"This is not smart.\" 95 | This isn\'t either. 96 | 5\'8\" 97 | . 98 | <p>&quot;This is not smart.&quot; 99 | This isn't either. 100 | 5'8&quot;</p> 101 | ```````````````````````````````` 102 | 103 | Two hyphens form an en-dash, three an em-dash. 104 | 105 | ```````````````````````````````` example 106 | Some dashes: em---em 107 | en--en 108 | em --- em 109 | en -- en 110 | 2--3 111 | . 112 | <p>Some dashes: em—em 113 | en–en 114 | em — em 115 | en – en 116 | 2–3</p> 117 | ```````````````````````````````` 118 | 119 | A sequence of more than three hyphens is 120 | parsed as a sequence of em and/or en dashes, 121 | with no hyphens. If possible, a homogeneous 122 | sequence of dashes is used (so, 10 hyphens 123 | = 5 en dashes, and 9 hyphens = 3 em dashes). 124 | When a heterogeneous sequence must be used, 125 | the em dashes come first, followed by the en 126 | dashes, and as few en dashes as possible are 127 | used (so, 7 hyphens = 2 em dashes an 1 en 128 | dash). 129 | 130 | ```````````````````````````````` example 131 | one- 132 | two-- 133 | three--- 134 | four---- 135 | five----- 136 | six------ 137 | seven------- 138 | eight-------- 139 | nine--------- 140 | thirteen-------------. 141 | . 142 | <p>one- 143 | two– 144 | three— 145 | four–– 146 | five—– 147 | six—— 148 | seven—–– 149 | eight–––– 150 | nine——— 151 | thirteen———––.</p> 152 | ```````````````````````````````` 153 | 154 | Hyphens can be escaped: 155 | 156 | ```````````````````````````````` example 157 | Escaped hyphens: \-- \-\-\-. 158 | . 159 | <p>Escaped hyphens: -- ---.</p> 160 | ```````````````````````````````` 161 | 162 | Three periods form an ellipsis: 163 | 164 | ```````````````````````````````` example 165 | Ellipses...and...and.... 166 | . 167 | <p>Ellipses…and…and….</p> 168 | ```````````````````````````````` 169 | 170 | Periods can be escaped if ellipsis-formation 171 | is not wanted: 172 | 173 | ```````````````````````````````` example 174 | No ellipses\.\.\. 175 | . 176 | <p>No ellipses...</p> 177 | ```````````````````````````````` 178 | -------------------------------------------------------------------------------- /src/iterator.c: -------------------------------------------------------------------------------- 1 | #include <assert.h> 2 | #include <stdlib.h> 3 | 4 | #include "config.h" 5 | #include "node.h" 6 | #include "cmark-gfm.h" 7 | #include "iterator.h" 8 | 9 | cmark_iter *cmark_iter_new(cmark_node *root) { 10 | if (root == NULL) { 11 | return NULL; 12 | } 13 | cmark_mem *mem = root->content.mem; 14 | cmark_iter *iter = (cmark_iter *)mem->calloc(1, sizeof(cmark_iter)); 15 | iter->mem = mem; 16 | iter->root = root; 17 | iter->cur.ev_type = CMARK_EVENT_NONE; 18 | iter->cur.node = NULL; 19 | iter->next.ev_type = CMARK_EVENT_ENTER; 20 | iter->next.node = root; 21 | return iter; 22 | } 23 | 24 | void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter); } 25 | 26 | static bool S_is_leaf(cmark_node *node) { 27 | switch (node->type) { 28 | case CMARK_NODE_HTML_BLOCK: 29 | case CMARK_NODE_THEMATIC_BREAK: 30 | case CMARK_NODE_CODE_BLOCK: 31 | case CMARK_NODE_TEXT: 32 | case CMARK_NODE_SOFTBREAK: 33 | case CMARK_NODE_LINEBREAK: 34 | case CMARK_NODE_CODE: 35 | case CMARK_NODE_HTML_INLINE: 36 | return 1; 37 | } 38 | return 0; 39 | } 40 | 41 | cmark_event_type cmark_iter_next(cmark_iter *iter) { 42 | cmark_event_type ev_type = iter->next.ev_type; 43 | cmark_node *node = iter->next.node; 44 | 45 | iter->cur.ev_type = ev_type; 46 | iter->cur.node = node; 47 | 48 | if (ev_type == CMARK_EVENT_DONE) { 49 | return ev_type; 50 | } 51 | 52 | /* roll forward to next item, setting both fields */ 53 | if (ev_type == CMARK_EVENT_ENTER && !S_is_leaf(node)) { 54 | if (node->first_child == NULL) { 55 | /* stay on this node but exit */ 56 | iter->next.ev_type = CMARK_EVENT_EXIT; 57 | } else { 58 | iter->next.ev_type = CMARK_EVENT_ENTER; 59 | iter->next.node = node->first_child; 60 | } 61 | } else if (node == iter->root) { 62 | /* don't move past root */ 63 | iter->next.ev_type = CMARK_EVENT_DONE; 64 | iter->next.node = NULL; 65 | } else if (node->next) { 66 | iter->next.ev_type = CMARK_EVENT_ENTER; 67 | iter->next.node = node->next; 68 | } else if (node->parent) { 69 | iter->next.ev_type = CMARK_EVENT_EXIT; 70 | iter->next.node = node->parent; 71 | } else { 72 | assert(false); 73 | iter->next.ev_type = CMARK_EVENT_DONE; 74 | iter->next.node = NULL; 75 | } 76 | 77 | return ev_type; 78 | } 79 | 80 | void cmark_iter_reset(cmark_iter *iter, cmark_node *current, 81 | cmark_event_type event_type) { 82 | iter->next.ev_type = event_type; 83 | iter->next.node = current; 84 | cmark_iter_next(iter); 85 | } 86 | 87 | cmark_node *cmark_iter_get_node(cmark_iter *iter) { return iter->cur.node; } 88 | 89 | cmark_event_type cmark_iter_get_event_type(cmark_iter *iter) { 90 | return iter->cur.ev_type; 91 | } 92 | 93 | cmark_node *cmark_iter_get_root(cmark_iter *iter) { return iter->root; } 94 | 95 | void cmark_consolidate_text_nodes(cmark_node *root) { 96 | if (root == NULL) { 97 | return; 98 | } 99 | cmark_iter *iter = cmark_iter_new(root); 100 | cmark_strbuf buf = CMARK_BUF_INIT(iter->mem); 101 | cmark_event_type ev_type; 102 | cmark_node *cur, *tmp, *next; 103 | 104 | while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { 105 | cur = cmark_iter_get_node(iter); 106 | if (ev_type == CMARK_EVENT_ENTER && cur->type == CMARK_NODE_TEXT && 107 | cur->next && cur->next->type == CMARK_NODE_TEXT) { 108 | cmark_strbuf_clear(&buf); 109 | cmark_strbuf_put(&buf, cur->as.literal.data, cur->as.literal.len); 110 | tmp = cur->next; 111 | while (tmp && tmp->type == CMARK_NODE_TEXT) { 112 | cmark_iter_next(iter); // advance pointer 113 | cmark_strbuf_put(&buf, tmp->as.literal.data, tmp->as.literal.len); 114 | cur->end_column = tmp->end_column; 115 | next = tmp->next; 116 | cmark_node_free(tmp); 117 | tmp = next; 118 | } 119 | cmark_chunk_free(iter->mem, &cur->as.literal); 120 | cur->as.literal = cmark_chunk_buf_detach(&buf); 121 | } 122 | } 123 | 124 | cmark_strbuf_free(&buf); 125 | cmark_iter_free(iter); 126 | } 127 | 128 | void cmark_node_own(cmark_node *root) { 129 | if (root == NULL) { 130 | return; 131 | } 132 | cmark_iter *iter = cmark_iter_new(root); 133 | cmark_event_type ev_type; 134 | cmark_node *cur; 135 | 136 | while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { 137 | cur = cmark_iter_get_node(iter); 138 | if (ev_type == CMARK_EVENT_ENTER) { 139 | switch (cur->type) { 140 | case CMARK_NODE_TEXT: 141 | case CMARK_NODE_HTML_INLINE: 142 | case CMARK_NODE_CODE: 143 | case CMARK_NODE_HTML_BLOCK: 144 | cmark_chunk_to_cstr(iter->mem, &cur->as.literal); 145 | break; 146 | case CMARK_NODE_LINK: 147 | cmark_chunk_to_cstr(iter->mem, &cur->as.link.url); 148 | cmark_chunk_to_cstr(iter->mem, &cur->as.link.title); 149 | break; 150 | case CMARK_NODE_CUSTOM_INLINE: 151 | cmark_chunk_to_cstr(iter->mem, &cur->as.custom.on_enter); 152 | cmark_chunk_to_cstr(iter->mem, &cur->as.custom.on_exit); 153 | break; 154 | } 155 | } 156 | } 157 | 158 | cmark_iter_free(iter); 159 | } 160 | -------------------------------------------------------------------------------- /man/make_man_page.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | # Creates a man page from a C file. 4 | 5 | # first argument if present is path to cmark dynamic library 6 | 7 | # Comments beginning with `/**` are treated as Groff man, except that 8 | # 'this' is converted to \fIthis\f[], and ''this'' to \fBthis\f[]. 9 | 10 | # Non-blank lines immediately following a man page comment are treated 11 | # as function signatures or examples and parsed into .Ft, .Fo, .Fa, .Fc. The 12 | # immediately preceding man documentation chunk is printed after the example 13 | # as a comment on it. 14 | 15 | # That's about it! 16 | 17 | import sys, re, os, platform 18 | from datetime import date 19 | from ctypes import CDLL, c_char_p, c_long, c_void_p 20 | 21 | sysname = platform.system() 22 | 23 | if sysname == 'Darwin': 24 | cmark = CDLL("build/src/libcmark-gfm.dylib") 25 | else: 26 | cmark = CDLL("build/src/libcmark-gfm.so") 27 | 28 | parse_document = cmark.cmark_parse_document 29 | parse_document.restype = c_void_p 30 | parse_document.argtypes = [c_char_p, c_long] 31 | 32 | render_man = cmark.cmark_render_man 33 | render_man.restype = c_char_p 34 | render_man.argtypes = [c_void_p, c_long, c_long] 35 | 36 | def md2man(text): 37 | if sys.version_info >= (3,0): 38 | textbytes = text.encode('utf-8') 39 | textlen = len(textbytes) 40 | return render_man(parse_document(textbytes, textlen), 0, 65).decode('utf-8') 41 | else: 42 | textbytes = text 43 | textlen = len(text) 44 | return render_man(parse_document(textbytes, textlen), 0, 72) 45 | 46 | comment_start_re = re.compile('^\/\*\* ?') 47 | comment_delim_re = re.compile('^[/ ]\** ?') 48 | comment_end_re = re.compile('^ \**\/') 49 | function_re = re.compile('^ *(?:CMARK_GFM_EXPORT\s+)?(?P<type>(?:const\s+)?\w+(?:\s*[*])?)\s*(?P<name>\w+)\s*\((?P<args>[^)]*)\)') 50 | blank_re = re.compile('^\s*$') 51 | macro_re = re.compile('CMARK_GFM_EXPORT *') 52 | typedef_start_re = re.compile('typedef.*{$') 53 | typedef_end_re = re.compile('}') 54 | single_quote_re = re.compile("(?<!\w)'([^']+)'(?!\w)") 55 | double_quote_re = re.compile("(?<!\w)''([^']+)''(?!\w)") 56 | 57 | def handle_quotes(s): 58 | return re.sub(double_quote_re, '**\g<1>**', re.sub(single_quote_re, '*\g<1>*', s)) 59 | 60 | typedef = False 61 | mdlines = [] 62 | chunk = [] 63 | sig = [] 64 | 65 | if len(sys.argv) > 1: 66 | sourcefile = sys.argv[1] 67 | else: 68 | print("Usage: make_man_page.py sourcefile") 69 | exit(1) 70 | 71 | with open(sourcefile, 'r') as cmarkh: 72 | state = 'default' 73 | for line in cmarkh: 74 | # state transition 75 | oldstate = state 76 | if comment_start_re.match(line): 77 | state = 'man' 78 | elif comment_end_re.match(line) and state == 'man': 79 | continue 80 | elif comment_delim_re.match(line) and state == 'man': 81 | state = 'man' 82 | elif not typedef and blank_re.match(line): 83 | state = 'default' 84 | elif typedef and typedef_end_re.match(line): 85 | typedef = False 86 | elif typedef_start_re.match(line): 87 | typedef = True 88 | state = 'signature' 89 | elif state == 'man': 90 | state = 'signature' 91 | 92 | # handle line 93 | if state == 'man': 94 | chunk.append(handle_quotes(re.sub(comment_delim_re, '', line))) 95 | elif state == 'signature': 96 | ln = re.sub(macro_re, '', line) 97 | if typedef or not re.match(blank_re, ln): 98 | sig.append(ln) 99 | elif oldstate == 'signature' and state != 'signature': 100 | if len(mdlines) > 0 and mdlines[-1] != '\n': 101 | mdlines.append('\n') 102 | rawsig = ''.join(sig) 103 | m = function_re.match(rawsig) 104 | mdlines.append('.PP\n') 105 | if m: 106 | mdlines.append('\\fI' + m.group('type') + '\\f[]' + ' ') 107 | mdlines.append('\\fB' + m.group('name') + '\\f[]' + '(') 108 | first = True 109 | for argument in re.split(',', m.group('args')): 110 | if not first: 111 | mdlines.append(', ') 112 | first = False 113 | mdlines.append('\\fI' + argument.strip() + '\\f[]') 114 | mdlines.append(')\n') 115 | else: 116 | mdlines.append('.nf\n\\fC\n.RS 0n\n') 117 | mdlines += sig 118 | mdlines.append('.RE\n\\f[]\n.fi\n') 119 | if len(mdlines) > 0 and mdlines[-1] != '\n': 120 | mdlines.append('\n') 121 | mdlines += md2man(''.join(chunk)) 122 | mdlines.append('\n') 123 | chunk = [] 124 | sig = [] 125 | elif oldstate == 'man' and state != 'signature': 126 | if len(mdlines) > 0 and mdlines[-1] != '\n': 127 | mdlines.append('\n') 128 | mdlines += md2man(''.join(chunk)) # add man chunk 129 | chunk = [] 130 | mdlines.append('\n') 131 | 132 | sys.stdout.write('.TH cmark-gfm 3 "' + date.today().strftime('%B %d, %Y') + '" "LOCAL" "Library Functions Manual"\n') 133 | sys.stdout.write(''.join(mdlines)) 134 | -------------------------------------------------------------------------------- /extensions/tasklist.c: -------------------------------------------------------------------------------- 1 | #include "tasklist.h" 2 | #include <parser.h> 3 | #include <render.h> 4 | #include <html.h> 5 | #include "ext_scanners.h" 6 | 7 | typedef enum { 8 | CMARK_TASKLIST_NOCHECKED, 9 | CMARK_TASKLIST_CHECKED, 10 | } cmark_tasklist_type; 11 | 12 | // Local constants 13 | static const char *TYPE_STRING = "tasklist"; 14 | 15 | static const char *get_type_string(cmark_syntax_extension *extension, cmark_node *node) { 16 | return TYPE_STRING; 17 | } 18 | 19 | 20 | // Return 1 if state was set, 0 otherwise 21 | int cmark_gfm_extensions_set_tasklist_item_checked(cmark_node *node, bool is_checked) { 22 | // The node has to exist, and be an extension, and actually be the right type in order to get the value. 23 | if (!node || !node->extension || strcmp(cmark_node_get_type_string(node), TYPE_STRING)) 24 | return 0; 25 | 26 | node->as.list.checked = is_checked; 27 | return 1; 28 | } 29 | 30 | bool cmark_gfm_extensions_get_tasklist_item_checked(cmark_node *node) { 31 | if (!node || !node->extension || strcmp(cmark_node_get_type_string(node), TYPE_STRING)) 32 | return false; 33 | 34 | if (node->as.list.checked) { 35 | return true; 36 | } 37 | else { 38 | return false; 39 | } 40 | } 41 | 42 | static bool parse_node_item_prefix(cmark_parser *parser, const char *input, 43 | cmark_node *container) { 44 | bool res = false; 45 | 46 | if (parser->indent >= 47 | container->as.list.marker_offset + container->as.list.padding) { 48 | cmark_parser_advance_offset(parser, input, container->as.list.marker_offset + 49 | container->as.list.padding, 50 | true); 51 | res = true; 52 | } else if (parser->blank && container->first_child != NULL) { 53 | // if container->first_child is NULL, then the opening line 54 | // of the list item was blank after the list marker; in this 55 | // case, we are done with the list item. 56 | cmark_parser_advance_offset(parser, input, parser->first_nonspace - parser->offset, 57 | false); 58 | res = true; 59 | } 60 | return res; 61 | } 62 | 63 | static int matches(cmark_syntax_extension *self, cmark_parser *parser, 64 | unsigned char *input, int len, 65 | cmark_node *parent_container) { 66 | return parse_node_item_prefix(parser, (const char*)input, parent_container); 67 | } 68 | 69 | static int can_contain(cmark_syntax_extension *extension, cmark_node *node, 70 | cmark_node_type child_type) { 71 | return (node->type == CMARK_NODE_ITEM) ? 1 : 0; 72 | } 73 | 74 | static cmark_node *open_tasklist_item(cmark_syntax_extension *self, 75 | int indented, cmark_parser *parser, 76 | cmark_node *parent_container, 77 | unsigned char *input, int len) { 78 | cmark_node_type node_type = cmark_node_get_type(parent_container); 79 | if (node_type != CMARK_NODE_ITEM) { 80 | return NULL; 81 | } 82 | 83 | bufsize_t matched = scan_tasklist(input, len, 0); 84 | if (!matched) { 85 | return NULL; 86 | } 87 | 88 | cmark_node_set_syntax_extension(parent_container, self); 89 | cmark_parser_advance_offset(parser, (char *)input, 3, false); 90 | 91 | // Either an upper or lower case X means the task is completed. 92 | parent_container->as.list.checked = (strstr((char*)input, "[x]") || strstr((char*)input, "[X]")); 93 | 94 | return NULL; 95 | } 96 | 97 | static void commonmark_render(cmark_syntax_extension *extension, 98 | cmark_renderer *renderer, cmark_node *node, 99 | cmark_event_type ev_type, int options) { 100 | bool entering = (ev_type == CMARK_EVENT_ENTER); 101 | if (entering) { 102 | renderer->cr(renderer); 103 | if (node->as.list.checked) { 104 | renderer->out(renderer, node, "- [x] ", false, LITERAL); 105 | } else { 106 | renderer->out(renderer, node, "- [ ] ", false, LITERAL); 107 | } 108 | cmark_strbuf_puts(renderer->prefix, " "); 109 | } else { 110 | cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 2); 111 | renderer->cr(renderer); 112 | } 113 | } 114 | 115 | static void html_render(cmark_syntax_extension *extension, 116 | cmark_html_renderer *renderer, cmark_node *node, 117 | cmark_event_type ev_type, int options) { 118 | bool entering = (ev_type == CMARK_EVENT_ENTER); 119 | if (entering) { 120 | cmark_html_render_cr(renderer->html); 121 | cmark_strbuf_puts(renderer->html, "<li"); 122 | cmark_html_render_sourcepos(node, renderer->html, options); 123 | cmark_strbuf_putc(renderer->html, '>'); 124 | if (node->as.list.checked) { 125 | cmark_strbuf_puts(renderer->html, "<input type=\"checkbox\" checked=\"\" disabled=\"\" /> "); 126 | } else { 127 | cmark_strbuf_puts(renderer->html, "<input type=\"checkbox\" disabled=\"\" /> "); 128 | } 129 | } else { 130 | cmark_strbuf_puts(renderer->html, "</li>\n"); 131 | } 132 | } 133 | 134 | static const char *xml_attr(cmark_syntax_extension *extension, 135 | cmark_node *node) { 136 | if (node->as.list.checked) { 137 | return " completed=\"true\""; 138 | } else { 139 | return " completed=\"false\""; 140 | } 141 | } 142 | 143 | cmark_syntax_extension *create_tasklist_extension(void) { 144 | cmark_syntax_extension *ext = cmark_syntax_extension_new("tasklist"); 145 | 146 | cmark_syntax_extension_set_match_block_func(ext, matches); 147 | cmark_syntax_extension_set_get_type_string_func(ext, get_type_string); 148 | cmark_syntax_extension_set_open_block_func(ext, open_tasklist_item); 149 | cmark_syntax_extension_set_can_contain_func(ext, can_contain); 150 | cmark_syntax_extension_set_commonmark_render_func(ext, commonmark_render); 151 | cmark_syntax_extension_set_plaintext_render_func(ext, commonmark_render); 152 | cmark_syntax_extension_set_html_render_func(ext, html_render); 153 | cmark_syntax_extension_set_xml_attr_func(ext, xml_attr); 154 | 155 | return ext; 156 | } 157 | -------------------------------------------------------------------------------- /src/syntax_extension.c: -------------------------------------------------------------------------------- 1 | #include <stdlib.h> 2 | #include <assert.h> 3 | 4 | #include "cmark-gfm.h" 5 | #include "syntax_extension.h" 6 | #include "buffer.h" 7 | 8 | extern cmark_mem CMARK_DEFAULT_MEM_ALLOCATOR; 9 | 10 | static cmark_mem *_mem = &CMARK_DEFAULT_MEM_ALLOCATOR; 11 | 12 | void cmark_syntax_extension_free(cmark_mem *mem, cmark_syntax_extension *extension) { 13 | if (extension->free_function && extension->priv) { 14 | extension->free_function(mem, extension->priv); 15 | } 16 | 17 | cmark_llist_free(mem, extension->special_inline_chars); 18 | mem->free(extension->name); 19 | mem->free(extension); 20 | } 21 | 22 | cmark_syntax_extension *cmark_syntax_extension_new(const char *name) { 23 | cmark_syntax_extension *res = (cmark_syntax_extension *) _mem->calloc(1, sizeof(cmark_syntax_extension)); 24 | res->name = (char *) _mem->calloc(1, sizeof(char) * (strlen(name)) + 1); 25 | strcpy(res->name, name); 26 | return res; 27 | } 28 | 29 | cmark_node_type cmark_syntax_extension_add_node(int is_inline) { 30 | cmark_node_type *ref = !is_inline ? &CMARK_NODE_LAST_BLOCK : &CMARK_NODE_LAST_INLINE; 31 | 32 | if ((*ref & CMARK_NODE_VALUE_MASK) == CMARK_NODE_VALUE_MASK) { 33 | assert(false); 34 | return (cmark_node_type) 0; 35 | } 36 | 37 | return *ref = (cmark_node_type) ((int) *ref + 1); 38 | } 39 | 40 | void cmark_syntax_extension_set_emphasis(cmark_syntax_extension *extension, 41 | int emphasis) { 42 | extension->emphasis = emphasis == 1; 43 | } 44 | 45 | void cmark_syntax_extension_set_open_block_func(cmark_syntax_extension *extension, 46 | cmark_open_block_func func) { 47 | extension->try_opening_block = func; 48 | } 49 | 50 | void cmark_syntax_extension_set_match_block_func(cmark_syntax_extension *extension, 51 | cmark_match_block_func func) { 52 | extension->last_block_matches = func; 53 | } 54 | 55 | void cmark_syntax_extension_set_match_inline_func(cmark_syntax_extension *extension, 56 | cmark_match_inline_func func) { 57 | extension->match_inline = func; 58 | } 59 | 60 | void cmark_syntax_extension_set_inline_from_delim_func(cmark_syntax_extension *extension, 61 | cmark_inline_from_delim_func func) { 62 | extension->insert_inline_from_delim = func; 63 | } 64 | 65 | void cmark_syntax_extension_set_special_inline_chars(cmark_syntax_extension *extension, 66 | cmark_llist *special_chars) { 67 | extension->special_inline_chars = special_chars; 68 | } 69 | 70 | void cmark_syntax_extension_set_get_type_string_func(cmark_syntax_extension *extension, 71 | cmark_get_type_string_func func) { 72 | extension->get_type_string_func = func; 73 | } 74 | 75 | void cmark_syntax_extension_set_can_contain_func(cmark_syntax_extension *extension, 76 | cmark_can_contain_func func) { 77 | extension->can_contain_func = func; 78 | } 79 | 80 | void cmark_syntax_extension_set_contains_inlines_func(cmark_syntax_extension *extension, 81 | cmark_contains_inlines_func func) { 82 | extension->contains_inlines_func = func; 83 | } 84 | 85 | void cmark_syntax_extension_set_commonmark_render_func(cmark_syntax_extension *extension, 86 | cmark_common_render_func func) { 87 | extension->commonmark_render_func = func; 88 | } 89 | 90 | void cmark_syntax_extension_set_plaintext_render_func(cmark_syntax_extension *extension, 91 | cmark_common_render_func func) { 92 | extension->plaintext_render_func = func; 93 | } 94 | 95 | void cmark_syntax_extension_set_latex_render_func(cmark_syntax_extension *extension, 96 | cmark_common_render_func func) { 97 | extension->latex_render_func = func; 98 | } 99 | 100 | void cmark_syntax_extension_set_xml_attr_func(cmark_syntax_extension *extension, 101 | cmark_xml_attr_func func) { 102 | extension->xml_attr_func = func; 103 | } 104 | 105 | void cmark_syntax_extension_set_man_render_func(cmark_syntax_extension *extension, 106 | cmark_common_render_func func) { 107 | extension->man_render_func = func; 108 | } 109 | 110 | void cmark_syntax_extension_set_html_render_func(cmark_syntax_extension *extension, 111 | cmark_html_render_func func) { 112 | extension->html_render_func = func; 113 | } 114 | 115 | void cmark_syntax_extension_set_html_filter_func(cmark_syntax_extension *extension, 116 | cmark_html_filter_func func) { 117 | extension->html_filter_func = func; 118 | } 119 | 120 | void cmark_syntax_extension_set_postprocess_func(cmark_syntax_extension *extension, 121 | cmark_postprocess_func func) { 122 | extension->postprocess_func = func; 123 | } 124 | 125 | void cmark_syntax_extension_set_private(cmark_syntax_extension *extension, 126 | void *priv, 127 | cmark_free_func free_func) { 128 | extension->priv = priv; 129 | extension->free_function = free_func; 130 | } 131 | 132 | void *cmark_syntax_extension_get_private(cmark_syntax_extension *extension) { 133 | return extension->priv; 134 | } 135 | 136 | void cmark_syntax_extension_set_opaque_alloc_func(cmark_syntax_extension *extension, 137 | cmark_opaque_alloc_func func) { 138 | extension->opaque_alloc_func = func; 139 | } 140 | 141 | void cmark_syntax_extension_set_opaque_free_func(cmark_syntax_extension *extension, 142 | cmark_opaque_free_func func) { 143 | extension->opaque_free_func = func; 144 | } 145 | 146 | void cmark_syntax_extension_set_commonmark_escape_func(cmark_syntax_extension *extension, 147 | cmark_commonmark_escape_func func) { 148 | extension->commonmark_escape_func = func; 149 | } 150 | -------------------------------------------------------------------------------- /test/pathological_tests.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | 4 | import re 5 | import argparse 6 | import sys 7 | import platform 8 | import itertools 9 | import multiprocessing 10 | from cmark import CMark 11 | 12 | def hash_collisions(): 13 | REFMAP_SIZE = 16 14 | COUNT = 50000 15 | 16 | def badhash(ref): 17 | h = 0 18 | for c in ref: 19 | a = (h << 6) & 0xFFFFFFFF 20 | b = (h << 16) & 0xFFFFFFFF 21 | h = ord(c) + a + b - h 22 | h = h & 0xFFFFFFFF 23 | 24 | return (h % REFMAP_SIZE) == 0 25 | 26 | keys = ("x%d" % i for i in itertools.count()) 27 | collisions = itertools.islice((k for k in keys if badhash(k)), COUNT) 28 | bad_key = next(collisions) 29 | 30 | document = ''.join("[%s]: /url\n\n[%s]\n\n" % (key, bad_key) for key in collisions) 31 | 32 | return document, re.compile("(<p>\[%s\]</p>\n){%d}" % (bad_key, COUNT-1)) 33 | 34 | allowed_failures = {"many references": True} 35 | 36 | # list of pairs consisting of input and a regex that must match the output. 37 | pathological = { 38 | # note - some pythons have limit of 65535 for {num-matches} in re. 39 | "nested strong emph": 40 | (("*a **a " * 65000) + "b" + (" a** a*" * 65000), 41 | re.compile("(<em>a <strong>a ){65000}b( a</strong> a</em>){65000}")), 42 | "many emph closers with no openers": 43 | (("a_ " * 65000), 44 | re.compile("(a[_] ){64999}a_")), 45 | "many emph openers with no closers": 46 | (("_a " * 65000), 47 | re.compile("(_a ){64999}_a")), 48 | "many link closers with no openers": 49 | (("a]" * 65000), 50 | re.compile("(a\]){65000}")), 51 | "many link openers with no closers": 52 | (("[a" * 65000), 53 | re.compile("(\[a){65000}")), 54 | "mismatched openers and closers": 55 | (("*a_ " * 50000), 56 | re.compile("([*]a[_] ){49999}[*]a_")), 57 | "openers and closers multiple of 3": 58 | (("a**b" + ("c* " * 50000)), 59 | re.compile("a[*][*]b(c[*] ){49999}c[*]")), 60 | "link openers and emph closers": 61 | (("[ a_" * 50000), 62 | re.compile("(\[ a_){50000}")), 63 | "pattern [ (]( repeated": 64 | (("[ (](" * 80000), 65 | re.compile("(\[ \(\]\(){80000}")), 66 | "pattern ![[]() repeated": 67 | ("![[]()" * 160000, 68 | re.compile("(!\[<a href=\"\"></a>){160000}")), 69 | "hard link/emph case": 70 | ("**x [a*b**c*](d)", 71 | re.compile("\\*\\*x <a href=\"d\">a<em>b\\*\\*c</em></a>")), 72 | "nested brackets": 73 | (("[" * 50000) + "a" + ("]" * 50000), 74 | re.compile("\[{50000}a\]{50000}")), 75 | "nested block quotes": 76 | ((("> " * 50000) + "a"), 77 | re.compile("(<blockquote>\n){50000}")), 78 | "deeply nested lists": 79 | ("".join(map(lambda x: (" " * x + "* a\n"), range(0,1000))), 80 | re.compile("<ul>\n(<li>a\n<ul>\n){999}<li>a</li>\n</ul>\n(</li>\n</ul>\n){999}")), 81 | "U+0000 in input": 82 | ("abc\u0000de\u0000", 83 | re.compile("abc\ufffd?de\ufffd?")), 84 | "backticks": 85 | ("".join(map(lambda x: ("e" + "`" * x), range(1,5000))), 86 | re.compile("^<p>[e`]*</p>\n$")), 87 | "unclosed links A": 88 | ("[a](<b" * 30000, 89 | re.compile("(\[a\]\(&lt;b){30000}")), 90 | "unclosed links B": 91 | ("[a](b" * 30000, 92 | re.compile("(\[a\]\(b){30000}")), 93 | "unclosed <!--": 94 | ("</" + "<!--" * 300000, 95 | re.compile("\&lt;\/(\&lt;!--){300000}")), 96 | "tables": 97 | ("aaa\rbbb\n-\v\n" * 30000, 98 | re.compile("^<p>aaa</p>\n<table>\n<thead>\n<tr>\n<th>bbb</th>\n</tr>\n</thead>\n<tbody>\n(<tr>\n<td>aaa</td>\n</tr>\n<tr>\n<td>bbb</td>\n</tr>\n<tr>\n<td>-\x0b</td>\n</tr>\n){29999}</tbody>\n</table>\n$")), 99 | # "many references": 100 | # ("".join(map(lambda x: ("[" + str(x) + "]: u\n"), range(1,5000 * 16))) + "[0] " * 5000, 101 | # re.compile("(\[0\] ){4999}")), 102 | "reference collisions": hash_collisions() 103 | } 104 | 105 | whitespace_re = re.compile('/s+/') 106 | passed = 0 107 | errored = 0 108 | ignored = 0 109 | TIMEOUT = 5 110 | 111 | def run_test(inp, regex): 112 | parser = argparse.ArgumentParser(description='Run cmark tests.') 113 | parser.add_argument('--program', dest='program', nargs='?', default=None, 114 | help='program to test') 115 | parser.add_argument('--library-dir', dest='library_dir', nargs='?', 116 | default=None, help='directory containing dynamic library') 117 | args = parser.parse_args(sys.argv[1:]) 118 | cmark = CMark(prog=args.program, library_dir=args.library_dir, extensions="table") 119 | 120 | [rc, actual, err] = cmark.to_html(inp) 121 | if rc != 0: 122 | print('[ERRORED (return code %d)]' % rc) 123 | print(err) 124 | exit(1) 125 | elif regex.search(actual): 126 | print('[PASSED]') 127 | else: 128 | print('[FAILED (mismatch)]') 129 | print(repr(actual)) 130 | exit(1) 131 | 132 | if __name__ == '__main__': 133 | print("Testing pathological cases:") 134 | for description in pathological: 135 | (inp, regex) = pathological[description] 136 | print(description, "... ", end='') 137 | sys.stdout.flush() 138 | 139 | p = multiprocessing.Process(target=run_test, args=(inp, regex)) 140 | p.start() 141 | p.join(TIMEOUT) 142 | 143 | if p.is_alive(): 144 | p.terminate() 145 | p.join() 146 | print('[TIMED OUT]') 147 | if allowed_failures[description]: 148 | ignored += 1 149 | else: 150 | errored += 1 151 | elif p.exitcode != 0: 152 | if allowed_failures[description]: 153 | ignored += 1 154 | else: 155 | errored += 1 156 | else: 157 | passed += 1 158 | 159 | print("%d passed, %d errored, %d ignored" % (passed, errored, ignored)) 160 | exit(errored) 161 | -------------------------------------------------------------------------------- /extensions/strikethrough.c: -------------------------------------------------------------------------------- 1 | #include "strikethrough.h" 2 | #include <parser.h> 3 | #include <render.h> 4 | 5 | cmark_node_type CMARK_NODE_STRIKETHROUGH; 6 | 7 | static cmark_node *match(cmark_syntax_extension *self, cmark_parser *parser, 8 | cmark_node *parent, unsigned char character, 9 | cmark_inline_parser *inline_parser) { 10 | cmark_node *res = NULL; 11 | int left_flanking, right_flanking, punct_before, punct_after, delims; 12 | char buffer[101]; 13 | 14 | if (character != '~') 15 | return NULL; 16 | 17 | delims = cmark_inline_parser_scan_delimiters( 18 | inline_parser, sizeof(buffer) - 1, '~', 19 | &left_flanking, 20 | &right_flanking, &punct_before, &punct_after); 21 | 22 | memset(buffer, '~', delims); 23 | buffer[delims] = 0; 24 | 25 | res = cmark_node_new_with_mem(CMARK_NODE_TEXT, parser->mem); 26 | cmark_node_set_literal(res, buffer); 27 | res->start_line = res->end_line = cmark_inline_parser_get_line(inline_parser); 28 | res->start_column = cmark_inline_parser_get_column(inline_parser) - delims; 29 | 30 | if ((left_flanking || right_flanking) && 31 | (delims == 2 || (!(parser->options & CMARK_OPT_STRIKETHROUGH_DOUBLE_TILDE) && delims == 1))) { 32 | cmark_inline_parser_push_delimiter(inline_parser, character, left_flanking, 33 | right_flanking, res); 34 | } 35 | 36 | return res; 37 | } 38 | 39 | static delimiter *insert(cmark_syntax_extension *self, cmark_parser *parser, 40 | cmark_inline_parser *inline_parser, delimiter *opener, 41 | delimiter *closer) { 42 | cmark_node *strikethrough; 43 | cmark_node *tmp, *next; 44 | delimiter *delim, *tmp_delim; 45 | delimiter *res = closer->next; 46 | 47 | strikethrough = opener->inl_text; 48 | 49 | if (opener->inl_text->as.literal.len != closer->inl_text->as.literal.len) 50 | goto done; 51 | 52 | if (!cmark_node_set_type(strikethrough, CMARK_NODE_STRIKETHROUGH)) 53 | goto done; 54 | 55 | cmark_node_set_syntax_extension(strikethrough, self); 56 | 57 | tmp = cmark_node_next(opener->inl_text); 58 | 59 | while (tmp) { 60 | if (tmp == closer->inl_text) 61 | break; 62 | next = cmark_node_next(tmp); 63 | cmark_node_append_child(strikethrough, tmp); 64 | tmp = next; 65 | } 66 | 67 | strikethrough->end_column = closer->inl_text->start_column + closer->inl_text->as.literal.len - 1; 68 | cmark_node_free(closer->inl_text); 69 | 70 | done: 71 | delim = closer; 72 | while (delim != NULL && delim != opener) { 73 | tmp_delim = delim->previous; 74 | cmark_inline_parser_remove_delimiter(inline_parser, delim); 75 | delim = tmp_delim; 76 | } 77 | 78 | cmark_inline_parser_remove_delimiter(inline_parser, opener); 79 | 80 | return res; 81 | } 82 | 83 | static const char *get_type_string(cmark_syntax_extension *extension, 84 | cmark_node *node) { 85 | return node->type == CMARK_NODE_STRIKETHROUGH ? "strikethrough" : "<unknown>"; 86 | } 87 | 88 | static int can_contain(cmark_syntax_extension *extension, cmark_node *node, 89 | cmark_node_type child_type) { 90 | if (node->type != CMARK_NODE_STRIKETHROUGH) 91 | return false; 92 | 93 | return CMARK_NODE_TYPE_INLINE_P(child_type); 94 | } 95 | 96 | static void commonmark_render(cmark_syntax_extension *extension, 97 | cmark_renderer *renderer, cmark_node *node, 98 | cmark_event_type ev_type, int options) { 99 | renderer->out(renderer, node, "~~", false, LITERAL); 100 | } 101 | 102 | static void latex_render(cmark_syntax_extension *extension, 103 | cmark_renderer *renderer, cmark_node *node, 104 | cmark_event_type ev_type, int options) { 105 | // requires \usepackage{ulem} 106 | bool entering = (ev_type == CMARK_EVENT_ENTER); 107 | if (entering) { 108 | renderer->out(renderer, node, "\\sout{", false, LITERAL); 109 | } else { 110 | renderer->out(renderer, node, "}", false, LITERAL); 111 | } 112 | } 113 | 114 | static void man_render(cmark_syntax_extension *extension, 115 | cmark_renderer *renderer, cmark_node *node, 116 | cmark_event_type ev_type, int options) { 117 | bool entering = (ev_type == CMARK_EVENT_ENTER); 118 | if (entering) { 119 | renderer->cr(renderer); 120 | renderer->out(renderer, node, ".ST \"", false, LITERAL); 121 | } else { 122 | renderer->out(renderer, node, "\"", false, LITERAL); 123 | renderer->cr(renderer); 124 | } 125 | } 126 | 127 | static void html_render(cmark_syntax_extension *extension, 128 | cmark_html_renderer *renderer, cmark_node *node, 129 | cmark_event_type ev_type, int options) { 130 | bool entering = (ev_type == CMARK_EVENT_ENTER); 131 | if (entering) { 132 | cmark_strbuf_puts(renderer->html, "<del>"); 133 | } else { 134 | cmark_strbuf_puts(renderer->html, "</del>"); 135 | } 136 | } 137 | 138 | static void plaintext_render(cmark_syntax_extension *extension, 139 | cmark_renderer *renderer, cmark_node *node, 140 | cmark_event_type ev_type, int options) { 141 | renderer->out(renderer, node, "~", false, LITERAL); 142 | } 143 | 144 | cmark_syntax_extension *create_strikethrough_extension(void) { 145 | cmark_syntax_extension *ext = cmark_syntax_extension_new("strikethrough"); 146 | cmark_llist *special_chars = NULL; 147 | 148 | cmark_syntax_extension_set_get_type_string_func(ext, get_type_string); 149 | cmark_syntax_extension_set_can_contain_func(ext, can_contain); 150 | cmark_syntax_extension_set_commonmark_render_func(ext, commonmark_render); 151 | cmark_syntax_extension_set_latex_render_func(ext, latex_render); 152 | cmark_syntax_extension_set_man_render_func(ext, man_render); 153 | cmark_syntax_extension_set_html_render_func(ext, html_render); 154 | cmark_syntax_extension_set_plaintext_render_func(ext, plaintext_render); 155 | CMARK_NODE_STRIKETHROUGH = cmark_syntax_extension_add_node(1); 156 | 157 | cmark_syntax_extension_set_match_inline_func(ext, match); 158 | cmark_syntax_extension_set_inline_from_delim_func(ext, insert); 159 | 160 | cmark_mem *mem = cmark_get_default_mem_allocator(); 161 | special_chars = cmark_llist_append(mem, special_chars, (void *)'~'); 162 | cmark_syntax_extension_set_special_inline_chars(ext, special_chars); 163 | 164 | cmark_syntax_extension_set_emphasis(ext, 1); 165 | 166 | return ext; 167 | } 168 | -------------------------------------------------------------------------------- /src/xml.c: -------------------------------------------------------------------------------- 1 | #include <stdlib.h> 2 | #include <stdio.h> 3 | #include <string.h> 4 | #include <assert.h> 5 | 6 | #include "config.h" 7 | #include "cmark-gfm.h" 8 | #include "node.h" 9 | #include "buffer.h" 10 | #include "houdini.h" 11 | #include "syntax_extension.h" 12 | 13 | #define BUFFER_SIZE 100 14 | #define MAX_INDENT 40 15 | 16 | // Functions to convert cmark_nodes to XML strings. 17 | 18 | static void escape_xml(cmark_strbuf *dest, const unsigned char *source, 19 | bufsize_t length) { 20 | houdini_escape_html0(dest, source, length, 0); 21 | } 22 | 23 | struct render_state { 24 | cmark_strbuf *xml; 25 | int indent; 26 | }; 27 | 28 | static CMARK_INLINE void indent(struct render_state *state) { 29 | int i; 30 | for (i = 0; i < state->indent && i < MAX_INDENT; i++) { 31 | cmark_strbuf_putc(state->xml, ' '); 32 | } 33 | } 34 | 35 | static int S_render_node(cmark_node *node, cmark_event_type ev_type, 36 | struct render_state *state, int options) { 37 | cmark_strbuf *xml = state->xml; 38 | bool literal = false; 39 | cmark_delim_type delim; 40 | bool entering = (ev_type == CMARK_EVENT_ENTER); 41 | char buffer[BUFFER_SIZE]; 42 | 43 | if (entering) { 44 | indent(state); 45 | cmark_strbuf_putc(xml, '<'); 46 | cmark_strbuf_puts(xml, cmark_node_get_type_string(node)); 47 | 48 | if (options & CMARK_OPT_SOURCEPOS && node->start_line != 0) { 49 | snprintf(buffer, BUFFER_SIZE, " sourcepos=\"%d:%d-%d:%d\"", 50 | node->start_line, node->start_column, node->end_line, 51 | node->end_column); 52 | cmark_strbuf_puts(xml, buffer); 53 | } 54 | 55 | if (node->extension && node->extension->xml_attr_func) { 56 | const char* r = node->extension->xml_attr_func(node->extension, node); 57 | if (r != NULL) 58 | cmark_strbuf_puts(xml, r); 59 | } 60 | 61 | literal = false; 62 | 63 | switch (node->type) { 64 | case CMARK_NODE_DOCUMENT: 65 | cmark_strbuf_puts(xml, " xmlns=\"http://commonmark.org/xml/1.0\""); 66 | break; 67 | case CMARK_NODE_TEXT: 68 | case CMARK_NODE_CODE: 69 | case CMARK_NODE_HTML_BLOCK: 70 | case CMARK_NODE_HTML_INLINE: 71 | cmark_strbuf_puts(xml, " xml:space=\"preserve\">"); 72 | escape_xml(xml, node->as.literal.data, node->as.literal.len); 73 | cmark_strbuf_puts(xml, "</"); 74 | cmark_strbuf_puts(xml, cmark_node_get_type_string(node)); 75 | literal = true; 76 | break; 77 | case CMARK_NODE_LIST: 78 | switch (cmark_node_get_list_type(node)) { 79 | case CMARK_ORDERED_LIST: 80 | cmark_strbuf_puts(xml, " type=\"ordered\""); 81 | snprintf(buffer, BUFFER_SIZE, " start=\"%d\"", 82 | cmark_node_get_list_start(node)); 83 | cmark_strbuf_puts(xml, buffer); 84 | delim = cmark_node_get_list_delim(node); 85 | if (delim == CMARK_PAREN_DELIM) { 86 | cmark_strbuf_puts(xml, " delim=\"paren\""); 87 | } else if (delim == CMARK_PERIOD_DELIM) { 88 | cmark_strbuf_puts(xml, " delim=\"period\""); 89 | } 90 | break; 91 | case CMARK_BULLET_LIST: 92 | cmark_strbuf_puts(xml, " type=\"bullet\""); 93 | break; 94 | default: 95 | break; 96 | } 97 | snprintf(buffer, BUFFER_SIZE, " tight=\"%s\"", 98 | (cmark_node_get_list_tight(node) ? "true" : "false")); 99 | cmark_strbuf_puts(xml, buffer); 100 | break; 101 | case CMARK_NODE_HEADING: 102 | snprintf(buffer, BUFFER_SIZE, " level=\"%d\"", node->as.heading.level); 103 | cmark_strbuf_puts(xml, buffer); 104 | break; 105 | case CMARK_NODE_CODE_BLOCK: 106 | if (node->as.code.info.len > 0) { 107 | cmark_strbuf_puts(xml, " info=\""); 108 | escape_xml(xml, node->as.code.info.data, node->as.code.info.len); 109 | cmark_strbuf_putc(xml, '"'); 110 | } 111 | cmark_strbuf_puts(xml, " xml:space=\"preserve\">"); 112 | escape_xml(xml, node->as.code.literal.data, node->as.code.literal.len); 113 | cmark_strbuf_puts(xml, "</"); 114 | cmark_strbuf_puts(xml, cmark_node_get_type_string(node)); 115 | literal = true; 116 | break; 117 | case CMARK_NODE_CUSTOM_BLOCK: 118 | case CMARK_NODE_CUSTOM_INLINE: 119 | cmark_strbuf_puts(xml, " on_enter=\""); 120 | escape_xml(xml, node->as.custom.on_enter.data, 121 | node->as.custom.on_enter.len); 122 | cmark_strbuf_putc(xml, '"'); 123 | cmark_strbuf_puts(xml, " on_exit=\""); 124 | escape_xml(xml, node->as.custom.on_exit.data, 125 | node->as.custom.on_exit.len); 126 | cmark_strbuf_putc(xml, '"'); 127 | break; 128 | case CMARK_NODE_LINK: 129 | case CMARK_NODE_IMAGE: 130 | cmark_strbuf_puts(xml, " destination=\""); 131 | escape_xml(xml, node->as.link.url.data, node->as.link.url.len); 132 | cmark_strbuf_putc(xml, '"'); 133 | cmark_strbuf_puts(xml, " title=\""); 134 | escape_xml(xml, node->as.link.title.data, node->as.link.title.len); 135 | cmark_strbuf_putc(xml, '"'); 136 | break; 137 | default: 138 | break; 139 | } 140 | if (node->first_child) { 141 | state->indent += 2; 142 | } else if (!literal) { 143 | cmark_strbuf_puts(xml, " /"); 144 | } 145 | cmark_strbuf_puts(xml, ">\n"); 146 | 147 | } else if (node->first_child) { 148 | state->indent -= 2; 149 | indent(state); 150 | cmark_strbuf_puts(xml, "</"); 151 | cmark_strbuf_puts(xml, cmark_node_get_type_string(node)); 152 | cmark_strbuf_puts(xml, ">\n"); 153 | } 154 | 155 | return 1; 156 | } 157 | 158 | char *cmark_render_xml(cmark_node *root, int options) { 159 | return cmark_render_xml_with_mem(root, options, cmark_node_mem(root)); 160 | } 161 | 162 | char *cmark_render_xml_with_mem(cmark_node *root, int options, cmark_mem *mem) { 163 | char *result; 164 | cmark_strbuf xml = CMARK_BUF_INIT(mem); 165 | cmark_event_type ev_type; 166 | cmark_node *cur; 167 | struct render_state state = {&xml, 0}; 168 | 169 | cmark_iter *iter = cmark_iter_new(root); 170 | 171 | cmark_strbuf_puts(state.xml, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); 172 | cmark_strbuf_puts(state.xml, 173 | "<!DOCTYPE document SYSTEM \"CommonMark.dtd\">\n"); 174 | while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { 175 | cur = cmark_iter_get_node(iter); 176 | S_render_node(cur, ev_type, &state, options); 177 | } 178 | result = (char *)cmark_strbuf_detach(&xml); 179 | 180 | cmark_iter_free(iter); 181 | return result; 182 | } 183 | -------------------------------------------------------------------------------- /src/plaintext.c: -------------------------------------------------------------------------------- 1 | #include "node.h" 2 | #include "syntax_extension.h" 3 | #include "render.h" 4 | 5 | #define OUT(s, wrap, escaping) renderer->out(renderer, node, s, wrap, escaping) 6 | #define LIT(s) renderer->out(renderer, node, s, false, LITERAL) 7 | #define CR() renderer->cr(renderer) 8 | #define BLANKLINE() renderer->blankline(renderer) 9 | #define LISTMARKER_SIZE 20 10 | 11 | // Functions to convert cmark_nodes to plain text strings. 12 | 13 | static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_node *node, 14 | cmark_escaping escape, 15 | int32_t c, unsigned char nextc) { 16 | cmark_render_code_point(renderer, c); 17 | } 18 | 19 | static int S_render_node(cmark_renderer *renderer, cmark_node *node, 20 | cmark_event_type ev_type, int options) { 21 | int list_number; 22 | cmark_delim_type list_delim; 23 | int i; 24 | bool entering = (ev_type == CMARK_EVENT_ENTER); 25 | char listmarker[LISTMARKER_SIZE]; 26 | bool first_in_list_item; 27 | bufsize_t marker_width; 28 | bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options) && 29 | !(CMARK_OPT_HARDBREAKS & options); 30 | 31 | // Don't adjust tight list status til we've started the list. 32 | // Otherwise we loose the blank line between a paragraph and 33 | // a following list. 34 | if (entering) { 35 | if (node->parent && node->parent->type == CMARK_NODE_ITEM) { 36 | renderer->in_tight_list_item = node->parent->parent->as.list.tight; 37 | } 38 | } else { 39 | if (node->type == CMARK_NODE_LIST) { 40 | renderer->in_tight_list_item = 41 | node->parent && 42 | node->parent->type == CMARK_NODE_ITEM && 43 | node->parent->parent->as.list.tight; 44 | } 45 | } 46 | 47 | if (node->extension && node->extension->plaintext_render_func) { 48 | node->extension->plaintext_render_func(node->extension, renderer, node, ev_type, options); 49 | return 1; 50 | } 51 | 52 | switch (node->type) { 53 | case CMARK_NODE_DOCUMENT: 54 | break; 55 | 56 | case CMARK_NODE_BLOCK_QUOTE: 57 | break; 58 | 59 | case CMARK_NODE_LIST: 60 | if (!entering && node->next && (node->next->type == CMARK_NODE_CODE_BLOCK || 61 | node->next->type == CMARK_NODE_LIST)) { 62 | CR(); 63 | } 64 | break; 65 | 66 | case CMARK_NODE_ITEM: 67 | if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { 68 | marker_width = 4; 69 | } else { 70 | list_number = cmark_node_get_item_index(node); 71 | list_delim = cmark_node_get_list_delim(node->parent); 72 | // we ensure a width of at least 4 so 73 | // we get nice transition from single digits 74 | // to double 75 | snprintf(listmarker, LISTMARKER_SIZE, "%d%s%s", list_number, 76 | list_delim == CMARK_PAREN_DELIM ? ")" : ".", 77 | list_number < 10 ? " " : " "); 78 | marker_width = (bufsize_t)strlen(listmarker); 79 | } 80 | if (entering) { 81 | if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { 82 | LIT(" - "); 83 | renderer->begin_content = true; 84 | } else { 85 | LIT(listmarker); 86 | renderer->begin_content = true; 87 | } 88 | for (i = marker_width; i--;) { 89 | cmark_strbuf_putc(renderer->prefix, ' '); 90 | } 91 | } else { 92 | cmark_strbuf_truncate(renderer->prefix, 93 | renderer->prefix->size - marker_width); 94 | CR(); 95 | } 96 | break; 97 | 98 | case CMARK_NODE_HEADING: 99 | if (entering) { 100 | renderer->begin_content = true; 101 | renderer->no_linebreaks = true; 102 | } else { 103 | renderer->no_linebreaks = false; 104 | BLANKLINE(); 105 | } 106 | break; 107 | 108 | case CMARK_NODE_CODE_BLOCK: 109 | first_in_list_item = node->prev == NULL && node->parent && 110 | node->parent->type == CMARK_NODE_ITEM; 111 | 112 | if (!first_in_list_item) { 113 | BLANKLINE(); 114 | } 115 | OUT(cmark_node_get_literal(node), false, LITERAL); 116 | BLANKLINE(); 117 | break; 118 | 119 | case CMARK_NODE_HTML_BLOCK: 120 | break; 121 | 122 | case CMARK_NODE_CUSTOM_BLOCK: 123 | break; 124 | 125 | case CMARK_NODE_THEMATIC_BREAK: 126 | BLANKLINE(); 127 | break; 128 | 129 | case CMARK_NODE_PARAGRAPH: 130 | if (!entering) { 131 | BLANKLINE(); 132 | } 133 | break; 134 | 135 | case CMARK_NODE_TEXT: 136 | OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); 137 | break; 138 | 139 | case CMARK_NODE_LINEBREAK: 140 | CR(); 141 | break; 142 | 143 | case CMARK_NODE_SOFTBREAK: 144 | if (CMARK_OPT_HARDBREAKS & options) { 145 | CR(); 146 | } else if (!renderer->no_linebreaks && renderer->width == 0 && 147 | !(CMARK_OPT_HARDBREAKS & options) && 148 | !(CMARK_OPT_NOBREAKS & options)) { 149 | CR(); 150 | } else { 151 | OUT(" ", allow_wrap, LITERAL); 152 | } 153 | break; 154 | 155 | case CMARK_NODE_CODE: 156 | OUT(cmark_node_get_literal(node), allow_wrap, LITERAL); 157 | break; 158 | 159 | case CMARK_NODE_HTML_INLINE: 160 | break; 161 | 162 | case CMARK_NODE_CUSTOM_INLINE: 163 | break; 164 | 165 | case CMARK_NODE_STRONG: 166 | break; 167 | 168 | case CMARK_NODE_EMPH: 169 | break; 170 | 171 | case CMARK_NODE_LINK: 172 | break; 173 | 174 | case CMARK_NODE_IMAGE: 175 | break; 176 | 177 | case CMARK_NODE_FOOTNOTE_REFERENCE: 178 | if (entering) { 179 | LIT("[^"); 180 | OUT(cmark_chunk_to_cstr(renderer->mem, &node->as.literal), false, LITERAL); 181 | LIT("]"); 182 | } 183 | break; 184 | 185 | case CMARK_NODE_FOOTNOTE_DEFINITION: 186 | if (entering) { 187 | renderer->footnote_ix += 1; 188 | LIT("[^"); 189 | char n[32]; 190 | snprintf(n, sizeof(n), "%d", renderer->footnote_ix); 191 | OUT(n, false, LITERAL); 192 | LIT("]: "); 193 | 194 | cmark_strbuf_puts(renderer->prefix, " "); 195 | } else { 196 | cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 4); 197 | } 198 | break; 199 | default: 200 | assert(false); 201 | break; 202 | } 203 | 204 | return 1; 205 | } 206 | 207 | char *cmark_render_plaintext(cmark_node *root, int options, int width) { 208 | return cmark_render_plaintext_with_mem(root, options, width, cmark_node_mem(root)); 209 | } 210 | 211 | char *cmark_render_plaintext_with_mem(cmark_node *root, int options, int width, cmark_mem *mem) { 212 | if (options & CMARK_OPT_HARDBREAKS) { 213 | // disable breaking on width, since it has 214 | // a different meaning with OPT_HARDBREAKS 215 | width = 0; 216 | } 217 | return cmark_render(mem, root, options, width, outc, S_render_node); 218 | } 219 | --------------------------------------------------------------------------------