├── .github
    └── workflows
    │   ├── ci-build.yml
    │   └── ci-fuzz.yml
├── .gitignore
├── CHANGELOG.md
├── CMakeLists.txt
├── LICENSE.md
├── README.md
├── md2html
    ├── CMakeLists.txt
    ├── cmdline.c
    ├── cmdline.h
    ├── md2html.1
    └── md2html.c
├── scripts
    ├── build_entity_map.py
    ├── build_folding_map.py
    ├── build_punct_map.py
    ├── build_whitespace_map.py
    ├── coverity.sh
    ├── run-tests.py
    └── unicode
    │   ├── CaseFolding.txt
    │   └── DerivedGeneralCategory.txt
├── src
    ├── CMakeLists.txt
    ├── entity.c
    ├── entity.h
    ├── md4c-html.c
    ├── md4c-html.h
    ├── md4c-html.pc.in
    ├── md4c.c
    ├── md4c.h
    └── md4c.pc.in
└── test
    ├── LICENSE.md
    ├── coverage.txt
    ├── fuzzers
        ├── fuzz-mdhtml.c
        └── seed-corpus
        │   ├── commonmark.md
        │   ├── gfm.md
        │   ├── latex-math.md
        │   └── wiki.md
    ├── normalize.py
    ├── pathological-tests.py
    ├── prog.py
    ├── regressions.txt
    ├── run-testsuite.py
    ├── spec-hard-soft-breaks.txt
    ├── spec-latex-math.txt
    ├── spec-permissive-autolinks.txt
    ├── spec-strikethrough.txt
    ├── spec-tables.txt
    ├── spec-tasklists.txt
    ├── spec-underline.txt
    ├── spec-wiki-links.txt
    └── spec.txt


/.github/workflows/ci-build.yml:
--------------------------------------------------------------------------------
 1 | name: Build and Test
 2 | 
 3 | on:
 4 |   - pull_request
 5 |   - push
 6 | 
 7 | jobs:
 8 |   # Linux builds.
 9 |   #
10 |   # gcc sometimes warns (e.g. about potentially uninitialized variables) only
11 |   # when some optimizations are enabled. So we build Debug as well as Release
12 |   # on Linux. The Debug build also collects and uploads test coverage.
13 |   linux-debug:
14 |     runs-on: ubuntu-latest
15 |     steps:
16 |       - name: Checkout
17 |         uses: actions/checkout@v4
18 |       - name: Configure
19 |         run: CFLAGS='--coverage -Werror' cmake -DCMAKE_BUILD_TYPE=Debug -G 'Unix Makefiles' .
20 |       - name: Build
21 |         run: make VERBOSE=1
22 |       - name: Test
23 |         run: python3 ./scripts/run-tests.py
24 |       - name: Create coverage report
25 |         run: |
26 |           sudo apt-get install -y lcov
27 |           lcov --directory . --capture --output-file coverage.info
28 |           lcov --remove coverage.info '/usr/*' --output-file coverage.info
29 |           lcov --list coverage.info
30 |       - name: Upload coverage report
31 |         uses: codecov/codecov-action@v4
32 |         env:
33 |           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
34 | 
35 |   linux-release:
36 |     runs-on: ubuntu-latest
37 |     steps:
38 |       - name: Checkout
39 |         uses: actions/checkout@v4
40 |       - name: Configure
41 |         run: CFLAGS='--coverage -Werror' cmake -DCMAKE_BUILD_TYPE=Release -G 'Unix Makefiles' .
42 |       - name: Build
43 |         run: make VERBOSE=1
44 |       - name: Test
45 |         run: python3 ./scripts/run-tests.py
46 | 
47 |   # Windows builds.
48 |   #
49 |   # We do both 32 and 64-bit builds. Also note 32-bit does Debug build while
50 |   # 64-bit one does Release build. (Full matrix would likely be an overkill.)
51 |   windows-32-debug:
52 |     runs-on: windows-latest
53 |     steps:
54 |       - name: Checkout
55 |         uses: actions/checkout@v4
56 |       - name: Dev command prompt
57 |         uses: ilammy/msvc-dev-cmd@v1
58 |         with:
59 |           arch: x86
60 |       - name: Configure
61 |         run: cmake -DCMAKE_BUILD_TYPE=Debug -G "NMake Makefiles" .
62 |       - name: Build
63 |         run: nmake
64 |       - name: Test
65 |         run: python .\scripts\run-tests.py
66 | 
67 |   windows-64-release:
68 |     runs-on: windows-latest
69 |     steps:
70 |       - name: Checkout
71 |         uses: actions/checkout@v4
72 |       - name: Dev command prompt
73 |         uses: ilammy/msvc-dev-cmd@v1
74 |         with:
75 |           arch: x64
76 |       - name: Configure
77 |         run: cmake -DCMAKE_BUILD_TYPE=Release -G "NMake Makefiles" .
78 |       - name: Build
79 |         run: nmake
80 |       - name: Test
81 |         run: python .\scripts\run-tests.py
82 | 


--------------------------------------------------------------------------------
/.github/workflows/ci-fuzz.yml:
--------------------------------------------------------------------------------
 1 | name: Fuzz Test
 2 | on:
 3 |   pull_request:
 4 |     paths:
 5 |       - '**.c'
 6 |       - '**.h'
 7 | jobs:
 8 |   Fuzzing:
 9 |     runs-on: ubuntu-latest
10 |     permissions:
11 |       security-events: write
12 |     steps:
13 |     - name: Build Fuzzers
14 |       id: build
15 |       uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
16 |       with:
17 |         oss-fuzz-project-name: 'md4c'
18 |         language: c
19 |     - name: Run Fuzzers
20 |       uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
21 |       with:
22 |         oss-fuzz-project-name: 'md4c'
23 |         fuzz-seconds: 600
24 |         output-sarif: true
25 |     - name: Upload Crash
26 |       uses: actions/upload-artifact@v3
27 |       if: failure() && steps.build.outcome == 'success'
28 |       with:
29 |         name: artifacts
30 |         path: ./out/artifacts   
31 |     - name: Upload Sarif
32 |       if: always() && steps.build.outcome == 'success'
33 |       uses: github/codeql-action/upload-sarif@v2
34 |       with:
35 |         # Path to SARIF file relative to the root of the repository
36 |         sarif_file: cifuzz-sarif/results.sarif
37 |         checkout_path: cifuzz-sarif
38 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Object files
 5 | *.o
 6 | *.ko
 7 | *.obj
 8 | *.elf
 9 | 
10 | # Linker output
11 | *.ilk
12 | *.map
13 | *.exp
14 | 
15 | # Precompiled Headers
16 | *.gch
17 | *.pch
18 | 
19 | # Libraries
20 | *.lib
21 | *.a
22 | *.la
23 | *.lo
24 | 
25 | # Shared objects (inc. Windows DLLs)
26 | *.dll
27 | *.so
28 | *.so.*
29 | *.dylib
30 | 
31 | # Executables
32 | *.exe
33 | *.out
34 | *.app
35 | *.i*86
36 | *.x86_64
37 | *.hex
38 | pfft
39 | 
40 | # Debug files
41 | *.dSYM/
42 | *.su
43 | *.idb
44 | *.pdb
45 | 
46 | # Kernel Module Compile Results
47 | *.mod*
48 | *.cmd
49 | .tmp_versions/
50 | modules.order
51 | Module.symvers
52 | Mkfile.old
53 | dkms.conf
54 | 
55 | # Temp files
56 | *.swp
57 | *.tmp
58 | *~
59 | ~*
60 | *.e
61 | 
62 | # autotools
63 | /aclocal.m4
64 | /autom4te.cache/
65 | /build/
66 | /build-aux/
67 | conf*.dir/
68 | /config.h
69 | /config.log
70 | /config.status
71 | /configure
72 | .deps/
73 | .dirstamp
74 | Makefile
75 | Makefile.in
76 | stamp-*
77 | *.stamp
78 | *.stamp-*
79 | .Tpo
80 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # MD4C Change Log
  3 | 
  4 | 
  5 | ## Next Version (Work in Progress)
  6 | 
  7 | Fixes:
  8 | 
  9 |  - [#236](https://github.com/mity/md4c/issues/236):
 10 |    Fix quadratic time behavior caused by one-by-one walking over block lines
 11 |    instead of calling `md_lookup_line()`.
 12 | 
 13 |  - [#238](https://github.com/mity/md4c/issues/238):
 14 |    Fix quadratic time and output size behavior caused by malicious misuse of
 15 |    link reference definitions.
 16 | 
 17 |  - [#242](https://github.com/mity/md4c/issues/242):
 18 |    The strike-through extension (with flag `MD_FLAG_STRIKETHROUGH`) now follows
 19 |    same logic as other emphasis spans in respect to punctuation character and
 20 |    word boundaries.
 21 | 
 22 |  - [#248](https://github.com/mity/md4c/issues/248):
 23 |    Fix handling tab when removing trailing whitespace, especially in connection
 24 |    with ATX headers.
 25 | 
 26 | 
 27 | ## Version 0.5.2
 28 | 
 29 | Changes:
 30 | 
 31 |  * Changes mandated by CommonMark specification 0.31:
 32 | 
 33 |    - The specification expands set of Unicode characters seen by Markdown
 34 |      parser as a punctuation. Namely all Unicode general categories P
 35 |      (punctuation) and S (symbols) are now seen as such.
 36 | 
 37 |    - The definition of HTML comment has been changed so that `<!-->` and
 38 |      `<!--->` are also recognized as HTML comments.
 39 | 
 40 |    - HTML tags recognized as HTML block starting condition of type 4 has been
 41 |      updated, namely a tag `<source>` has been removed, whereas `<search>`
 42 |      added.
 43 | 
 44 |    Refer to [CommonMark 0.31.2](https://spec.commonmark.org/0.31.2/) for full
 45 |    specification.
 46 | 
 47 | Fixes:
 48 | 
 49 |  - [#230](https://github.com/mity/md4c/issues/230):
 50 |    The fix [#223](https://github.com/mity/md4c/issues/223) in 0.5.1 release
 51 |    was incomplete and one corner case remained unfixed. This is now addressed.
 52 | 
 53 |  - [#231](https://github.com/mity/md4c/issues/231):
 54 |    `md2html --full-html` now emits `<meta charset="UTF-8">` in the HTML header.
 55 | 
 56 | 
 57 | ## Version 0.5.1
 58 | 
 59 | Changes:
 60 | 
 61 |  * LaTeX math extension (`MD_FLAG_LATEXMATHSPANS`) now requires that opener
 62 |    mark is not immediately preceded with alpha-numeric character and similarly
 63 |    that closer mark is not immediately followed with alpha-numeric character.
 64 | 
 65 |    So for example `foo$ x + y = z $` is not recognized as LaTeX equation
 66 |    anymore because there is no space between `foo` and the opening `$`.
 67 | 
 68 |  * Table extension (`MD_FLAG_TABLES`) now recognizes only tables with no more
 69 |    than 128 columns. This limit has been imposed to prevent a pathological
 70 |    case of quadratic output size explosion which could be used as DoS attack
 71 |    vector.
 72 | 
 73 |  * We are now more strict with `MD_FLAG_PERMISSIVExxxAUTOLINKS` family of
 74 |    extensions with respect to non-alphanumeric characters, with the aim to
 75 |    mitigate false positive detections.
 76 | 
 77 |    Only relatively few selected non-alphanumeric are now allowed in permissive
 78 |    e-mail auto-links (`MD_FLAG_PERMISSIVEEMAILAUTOLINKS`):
 79 |      - `.`, `-`, `_`, `+` in user name part of e-mail address; and
 80 |      - `.`, `-`, `_` in host part of the e-mail address.
 81 | 
 82 |    Similarly for URL and e-mail auto-links (`MD_FLAG_PERMISSIVEURLAUTOLINKS` and
 83 |    `MD_FLAG_PERMISSIVEWWWAUTOLINKS`):
 84 |      - `.`, `-`, `_` in host part of the URL;
 85 |      - `/`, `.`, `-`, `_` in path part of the URL;
 86 |      - `&`, `.`, `-`, `+`, `_`, `=`, `(`, `)` in the query part of the URL
 87 |        (additionally, if present, `(` and `)` must form balanced pairs); and
 88 |      - `.`, `-`, `+`, `_` in the fragment part of the URL.
 89 | 
 90 |    Furthermore these characters (with some exceptions like where they serve as
 91 |    delimiter characters, e.g. `/` for paths) are generally accepted only when
 92 |    an alphanumeric character both precedes and follows them (i.e. these cannot
 93 |    be "stacked" together).
 94 | 
 95 | Fixes:
 96 | 
 97 |  * Fix several bugs where we haven't properly respected already resolved spans
 98 |    of higher precedence level in handling of permissive auto-links extensions
 99 |    (family of `MD_FLAG_PERMISSIVExxxAUTOLINKS` flags), LaTeX math extension
100 |    (`MD_FLAG_LATEXMATHSPANS`) and wiki-links extension (`MD_FLAG_WIKILINKS`)
101 |    of the form `[[label|text]]` (with pipe `|`). In some complex cases this
102 |    could lead to invalid internal parser state and memory corruption.
103 | 
104 |    Identified with [OSS-Fuzz](https://github.com/google/oss-fuzz).
105 | 
106 |  * [#222](https://github.com/mity/md4c/issues/222):
107 |    Fix strike-through extension (`MD_FLAG_STRIKETHROUGH`) which did not respect
108 |    same rules for pairing opener and closer marks as other emphasis spans.
109 | 
110 |  * [#223](https://github.com/mity/md4c/issues/223):
111 |    Fix incorrect handling of new-line character just at the beginning and/or
112 |    end of a code span where we were not following CommonMark specification
113 |    requirements correctly.
114 | 
115 | 
116 | ## Version 0.5.0
117 | 
118 | Changes:
119 | 
120 |  * Changes mandated by CommonMark specification 0.30.
121 | 
122 |    Actually there are only very minor changes to recognition of HTML blocks:
123 | 
124 |    - The tag `<textarea>` now triggers HTML block (of type 1 as per the
125 |      specification).
126 | 
127 |    - HTML declaration (HTML block type 4) is not required to begin with an
128 |      upper-case ASCII character after the `<!`. Any ASCII character is now
129 |      allowed. Also it now doesn't require a whitespace before the closing `>`.
130 | 
131 |    Other than that, the newest specification mainly improves test coverage and
132 |    clarifies its wording in some cases, without affecting the implementation.
133 | 
134 |    Refer to [CommonMark 0.30](https://spec.commonmark.org/0.30/) for full
135 |    specification.
136 | 
137 |  * Make Unicode-specific code compliant to Unicode 15.1.
138 | 
139 |  * Update list of entities known to the HTML renderer from
140 |    https://html.spec.whatwg.org/entities.json.
141 | 
142 | New Features:
143 | 
144 |  * Add extension allowing to treat all soft break as hard ones. It has to be
145 |    explicitly enabled with `MD_FLAG_HARD_SOFT_BREAKS`.
146 | 
147 |    Contributed by [l-m](https://github.com/l1mey112).
148 | 
149 |  * Structure `MD_SPAN_A_DETAIL` now has a new member `is_autolink`.
150 | 
151 |    Contributed by [Jens Alfke](https://github.com/snej).
152 | 
153 |  * `md2html` utility now supports command line options `--html-title` and
154 |    `--html-css`.
155 | 
156 |    Contributed by [Andreas Baumann](https://github.com/andreasbaumann).
157 | 
158 | Fixes:
159 | 
160 |  * [#163](https://github.com/mity/md4c/issues/163):
161 |    Make HTML renderer to emit `'\n'` after the root tag when in the XHTML mode.
162 | 
163 |  * [#165](https://github.com/mity/md4c/issues/165):
164 |    Make HTML renderer not to percent-encode `'~'` in URLs. Although it does
165 |    work, it's not needed, and it can actually be confusing with URLs such as
166 |    `http://www.example.com/~johndoe/`.
167 | 
168 |  * [#167](https://github.com/mity/md4c/issues/167),
169 |    [#168](https://github.com/mity/md4c/issues/168):
170 |    Fix multiple instances of various buffer overflow bugs, found mostly using
171 |    a fuzz testing. Contributed by [dtldarek](https://github.com/dtldarek) and
172 |    [Thierry Coppey](https://github.com/TCKnet).
173 | 
174 |  * [#169](https://github.com/mity/md4c/issues/169):
175 |    Table underline now does not require 3 characters per table column anymore.
176 |    One dash (optionally with a leading or tailing `:` appended or prepended)
177 |    is now sufficient. This improves compatibility with the GFM.
178 | 
179 |  * [#172](https://github.com/mity/md4c/issues/172):
180 |    Fix quadratic time behavior caused by unnecessary lookup for link reference
181 |    definition even if the potential label contains nested brackets.
182 | 
183 |  * [#173](https://github.com/mity/md4c/issues/173),
184 |    [#174](https://github.com/mity/md4c/issues/174),
185 |    [#212](https://github.com/mity/md4c/issues/212),
186 |    [#213](https://github.com/mity/md4c/issues/213):
187 |    Multiple bugs identified with [OSS-Fuzz](https://github.com/google/oss-fuzz)
188 |    were fixed.
189 | 
190 |  * [#190](https://github.com/mity/md4c/issues/190),
191 |    [#200](https://github.com/mity/md4c/issues/200),
192 |    [#201](https://github.com/mity/md4c/issues/201):
193 |    Multiple fixes of incorrect interactions of indented code block with a
194 |    preceding block.
195 | 
196 |  * [#202](https://github.com/mity/md4c/issues/202):
197 |    We were not correctly calling `enter_block()` and `leave_block()` callbacks
198 |    if multiple HTML blocks followed one after another; instead previously
199 |    such blocks were merged into one.
200 | 
201 |    (This may likely impact only applications interested in Markdown's AST,
202 |    and not just converting Markdown to other formats like HTML.)
203 | 
204 |  * [#210](https://github.com/mity/md4c/issues/210):
205 |    The `md2html` utility now handles nested images with optional titles
206 |    correctly.
207 | 
208 |  * [#214](https://github.com/mity/md4c/issues/214):
209 |    Tags `<h2>` ... `<h6>` incorrectly did not trigger HTML block.
210 | 
211 |  * [#215](https://github.com/mity/md4c/issues/215):
212 |    The parser incorrectly did not accept optional tabs after setext header
213 |    underline.
214 | 
215 |  * [#217](https://github.com/mity/md4c/issues/217):
216 |    The parser incorrectly resolved emphasis in some situations, if the emphasis
217 |    marks were enclosed by punctuation characters.
218 | 
219 | 
220 | ## Version 0.4.8
221 | 
222 | Fixes:
223 | 
224 |  * [#149](https://github.com/mity/md4c/issues/149):
225 |    A HTML block started in a container block (and not explicitly finished in
226 |    the block) could eat 1 line of actual contents.
227 | 
228 |  * [#150](https://github.com/mity/md4c/issues/150):
229 |    Fix `md2html` to output proper DOCTYPE and HTML tags when `--full-html`
230 |    command line options is used, accordingly to the expected output format
231 |    (HTML or XHTML).
232 | 
233 |  * [#152](https://github.com/mity/md4c/issues/152):
234 |    Suppress recognition of a permissive autolink if it would otherwise form a
235 |    complete body of an outer inline link.
236 | 
237 |  * [#153](https://github.com/mity/md4c/issues/153),
238 |    [#154](https://github.com/mity/md4c/issues/154):
239 |    Set `MD_BLOCK_UL_DETAIL::mark` and `MD_BLOCK_OL_DETAIL::mark_delimiter`
240 |    correctly, even when the blocks are nested at the same line in a complicated
241 |    ways.
242 | 
243 |  * [#155](https://github.com/mity/md4c/issues/155):
244 |    Avoid reading 1 character beyond the input size in some complex cases.
245 | 
246 | 
247 | ## Version 0.4.7
248 | 
249 | Changes:
250 | 
251 |  * Add `MD_TABLE_DETAIL` structure into the API. The structure describes column
252 |    count and row count of the table, and pointer to it is passed into the
253 |    application-provided block callback with the `MD_BLOCK_TABLE` block type.
254 | 
255 | Fixes:
256 | 
257 |  * [#131](https://github.com/mity/md4c/issues/131):
258 |    Fix handling of a reference image nested in a reference link.
259 | 
260 |  * [#135](https://github.com/mity/md4c/issues/135):
261 |    Handle unmatched parenthesis pairs inside a permissive URL and WWW auto-links
262 |    in a way more compatible with the GFM.
263 | 
264 |  * [#138](https://github.com/mity/md4c/issues/138):
265 |    The tag `<tbody></tbody>` is now suppressed whenever the table has zero body
266 |    rows.
267 | 
268 |  * [#139](https://github.com/mity/md4c/issues/139):
269 |    Recognize a list item mark even when EOF follows it.
270 | 
271 |  * [#142](https://github.com/mity/md4c/issues/142):
272 |    Fix reference link definition label matching in a case when the label ends
273 |    with a Unicode character with non-trivial case folding mapping.
274 | 
275 | 
276 | ## Version 0.4.6
277 | 
278 | Fixes:
279 | 
280 |  * [#130](https://github.com/mity/md4c/issues/130):
281 |    Fix `ISANYOF` macro, which could provide unexpected results when encountering
282 |    zero byte in the input text; in some cases leading to broken internal state
283 |    of the parser.
284 | 
285 |    The bug could result in denial of service and possibly also to other security
286 |    implications. Applications are advised to update to 0.4.6.
287 | 
288 | 
289 | ## Version 0.4.5
290 | 
291 | Fixes:
292 | 
293 |  * [#118](https://github.com/mity/md4c/issues/118):
294 |    Fix HTML renderer's `MD_HTML_FLAG_VERBATIM_ENTITIES` flag, exposed in the
295 |    `md2html` utility via `--fverbatim-entities`.
296 | 
297 |  * [#124](https://github.com/mity/md4c/issues/124):
298 |    Fix handling of indentation of 16 or more spaces in the fenced code blocks.
299 | 
300 | 
301 | ## Version 0.4.4
302 | 
303 | Changes:
304 | 
305 |  * Make Unicode-specific code compliant to Unicode 13.0.
306 | 
307 | New features:
308 | 
309 |  * The HTML renderer, developed originally as the heart of the `md2html`
310 |    utility, is now built as a standalone library, in order to simplify its
311 |    reuse in applications.
312 | 
313 |  * With `MD_HTML_FLAG_SKIP_UTF8_BOM`, the HTML renderer now skips UTF-8 byte
314 |    order mark (BOM) if the input begins with it, before passing to the Markdown
315 |    parser.
316 | 
317 |    `md2html` utility automatically enables the flag (unless it is custom-built
318 |    with `-DMD4C_USE_ASCII`).
319 | 
320 |  * With `MD_HTML_FLAG_XHTML`, The HTML renderer generates XHTML instead of
321 |    HTML.
322 | 
323 |    This effectively means `<br />` instead of `<br>`, `<hr />` instead of
324 |    `<hr>`, and `<img ... />` instead of `<img ...>`.
325 | 
326 |    `md2html` utility now understands the command line option `-x` or `--xhtml`
327 |    enabling the XHTML mode.
328 | 
329 | Fixes:
330 | 
331 |  * [#113](https://github.com/mity/md4c/issues/113):
332 |    Add missing folding info data for the following Unicode characters:
333 |    `U+0184`, `U+018a`, `U+01b2`, `U+01b5`, `U+01f4`, `U+0372`, `U+038f`,
334 |    `U+1c84`, `U+1fb9`, `U+1fbb`, `U+1fd9`, `U+1fdb`, `U+1fe9`, `U+1feb`,
335 |    `U+1ff9`, `U+1ffb`, `U+2c7f`, `U+2ced`, `U+a77b`, `U+a792`, `U+a7c9`.
336 | 
337 |    Due the bug, the link definition label matching did not work in the case
338 |    insensitive way for these characters.
339 | 
340 | 
341 | ## Version 0.4.3
342 | 
343 | New features:
344 | 
345 |  * With `MD_FLAG_UNDERLINE`, spans enclosed in underscore (`_foo_`) are seen
346 |    as underline (`MD_SPAN_UNDERLINE`) rather than an ordinary emphasis or
347 |    strong emphasis.
348 | 
349 | Changes:
350 | 
351 |  * The implementation of wiki-links extension (with `MD_FLAG_WIKILINKS`) has
352 |    been simplified.
353 | 
354 |     - A noticeable increase of MD4C's memory footprint introduced by the
355 |       extension implementation in 0.4.0 has been removed.
356 |     - The priority handling towards other inline elements have been unified.
357 |       (This affects an obscure case where syntax of an image was in place of
358 |       wiki-link destination made the wiki-link invalid. Now *all* inline spans
359 |       in the wiki-link destination, including the images, is suppressed.)
360 |     - The length limitation of 100 characters now always applies to wiki-link
361 |       destination.
362 | 
363 |  * Recognition of strike-through spans (with the flag `MD_FLAG_STRIKETHROUGH`)
364 |    has become much stricter and, arguably, reasonable.
365 | 
366 |     - Only single tildes (`~`) and double tildes (`~~`) are recognized as
367 |       strike-through marks. Longer ones are not anymore.
368 |     - The length of the opener and closer marks have to be the same.
369 |     - The tildes cannot open a strike-through span if a whitespace follows.
370 |     - The tildes cannot close a strike-through span if a whitespace precedes.
371 | 
372 |    This change follows the changes of behavior in cmark-gfm some time ago, so
373 |    it is also beneficial from compatibility point of view.
374 | 
375 |  * When building MD4C by hand instead of using its CMake-based build, the UTF-8
376 |    support was by default disabled, unless explicitly asked for by defining
377 |    a preprocessor macro `MD4C_USE_UTF8`.
378 | 
379 |    This has been changed and the UTF-8 mode now becomes the default, no matter
380 |    how `md4c.c` is compiled. If you need to disable it and use the ASCII-only
381 |    mode, you have explicitly define macro `MD4C_USE_ASCII` when compiling it.
382 | 
383 |    (The CMake-based build as provided in our repository explicitly asked for
384 |    the UTF-8 support with `-DMD4C_USE_UTF8`. I.e. if you are using MD4C library
385 |    built with our vanilla `CMakeLists.txt` files, this change should not affect
386 |    you.)
387 | 
388 | Fixes:
389 | 
390 |  * Fixed some string length handling in the special `MD4C_USE_UTF16` build.
391 | 
392 |    (This does not affect you unless you are on Windows and explicitly define
393 |    the macro when building MD4C.)
394 | 
395 |  * [#100](https://github.com/mity/md4c/issues/100):
396 |    Fixed an off-by-one error in the maximal length limit of some segments
397 |    of e-mail addresses used in autolinks.
398 | 
399 |  * [#107](https://github.com/mity/md4c/issues/107):
400 |    Fix mis-detection of asterisk-encoded emphasis in some corner cases when
401 |    length of the opener and closer differs, as in `***foo *bar baz***`.
402 | 
403 | 
404 | ## Version 0.4.2
405 | 
406 | Fixes:
407 | 
408 |  * [#98](https://github.com/mity/md4c/issues/98):
409 |    Fix mis-detection of asterisk-encoded emphasis in some corner cases when
410 |    length of the opener and closer differs, as in `**a *b c** d*`.
411 | 
412 | 
413 | ## Version 0.4.1
414 | 
415 | Unfortunately, 0.4.0 has been released with badly updated ChangeLog. Fixing
416 | this is the only change on 0.4.1.
417 | 
418 | 
419 | ## Version 0.4.0
420 | 
421 | New features:
422 | 
423 |  * With `MD_FLAG_LATEXMATHSPANS`, LaTeX math spans (`$...$`) and LaTeX display
424 |    math spans (`$$...$$`) are now recognized. (Note though that the HTML
425 |    renderer outputs them verbatim in a custom `<x-equation>` tag.)
426 | 
427 |    Contributed by [Tilman Roeder](https://github.com/dyedgreen).
428 | 
429 |  * With `MD_FLAG_WIKILINKS`, Wiki-style links (`[[...]]`) are now recognized.
430 |    (Note though that the HTML renderer renders them as a custom `<x-wikilink>`
431 |    tag.)
432 | 
433 |    Contributed by [Nils Blomqvist](https://github.com/niblo).
434 | 
435 | Changes:
436 | 
437 |  * Parsing of tables (with `MD_FLAG_TABLES`) is now closer to the way how
438 |    cmark-gfm parses tables as we do not require every row of the table to
439 |    contain a pipe `|` anymore.
440 | 
441 |    As a consequence, paragraphs now cannot interrupt tables. A paragraph which
442 |    follows the table has to be delimited with a blank line.
443 | 
444 | Fixes:
445 | 
446 |  * [#94](https://github.com/mity/md4c/issues/94):
447 |    `md_build_ref_def_hashtable()`: Do not allocate more memory than strictly
448 |    needed.
449 | 
450 |  * [#95](https://github.com/mity/md4c/issues/95):
451 |    `md_is_container_mark()`: Ordered list mark requires at least one digit.
452 | 
453 |  * [#96](https://github.com/mity/md4c/issues/96):
454 |    Some fixes for link label comparison.
455 | 
456 | 
457 | ## Version 0.3.4
458 | 
459 | Changes:
460 | 
461 |  * Make Unicode-specific code compliant to Unicode 12.1.
462 | 
463 |  * Structure `MD_BLOCK_CODE_DETAIL` got new member `fenced_char`. Application
464 |    can use it to detect character used to form the block fences (`` ` `` or
465 |    `~`). In the case of indented code block, it is set to zero.
466 | 
467 | Fixes:
468 | 
469 |  * [#77](https://github.com/mity/md4c/issues/77):
470 |    Fix maximal count of digits for numerical character references, as requested
471 |    by CommonMark specification 0.29.
472 | 
473 |  * [#78](https://github.com/mity/md4c/issues/78):
474 |    Fix link reference definition label matching for Unicode characters where
475 |    the folding mapping leads to multiple codepoints, as e.g. in `ẞ` -> `SS`.
476 | 
477 |  * [#83](https://github.com/mity/md4c/issues/83):
478 |    Fix recognition of an empty blockquote which interrupts a paragraph.
479 | 
480 | 
481 | ## Version 0.3.3
482 | 
483 | Changes:
484 | 
485 |  * Make permissive URL autolink and permissive WWW autolink extensions stricter.
486 | 
487 |    This brings the behavior closer to GFM and mitigates risk of false positives.
488 |    In particular, the domain has to contain at least one dot and parenthesis
489 |    can be part of the link destination only if `(` and `)` are balanced.
490 | 
491 | Fixes:
492 | 
493 |  * [#73](https://github.com/mity/md4c/issues/73):
494 |    Some raw HTML inputs could lead to quadratic parsing times.
495 | 
496 |  * [#74](https://github.com/mity/md4c/issues/74):
497 |    Fix input leading to a crash. Found by fuzzing.
498 | 
499 |  * [#76](https://github.com/mity/md4c/issues/76):
500 |    Fix handling of parenthesis in some corner cases of permissive URL autolink
501 |    and permissive WWW autolink extensions.
502 | 
503 | 
504 | ## Version 0.3.2
505 | 
506 | Changes:
507 | 
508 |  * Changes mandated by CommonMark specification 0.29.
509 | 
510 |    Most importantly, the white-space trimming rules for code spans have changed.
511 |    At most one space/newline is trimmed from beginning/end of the code span
512 |    (if the code span contains some non-space contents, and if it begins and
513 |    ends with space at the same time). In all other cases the spaces in the code
514 |    span are now left intact.
515 | 
516 |    Other changes in behavior are in corner cases only. Refer to [CommonMark
517 |    0.29 notes](https://github.com/commonmark/commonmark-spec/releases/tag/0.29)
518 |    for more info.
519 | 
520 | Fixes:
521 | 
522 |  * [#68](https://github.com/mity/md4c/issues/68):
523 |    Some specific HTML blocks were not recognized when EOF follows without any
524 |    end-of-line character.
525 | 
526 |  * [#69](https://github.com/mity/md4c/issues/69):
527 |    Strike-through span not working correctly when its opener mark is directly
528 |    followed by other opener mark; or when other closer mark directly precedes
529 |    its closer mark.
530 | 
531 | 
532 | ## Version 0.3.1
533 | 
534 | Fixes:
535 | 
536 |  * [#58](https://github.com/mity/md4c/issues/58),
537 |    [#59](https://github.com/mity/md4c/issues/59),
538 |    [#60](https://github.com/mity/md4c/issues/60),
539 |    [#63](https://github.com/mity/md4c/issues/63),
540 |    [#66](https://github.com/mity/md4c/issues/66):
541 |    Some inputs could lead to quadratic parsing times. Thanks to Anders Kaseorg
542 |    for finding all those issues.
543 | 
544 |  * [#61](https://github.com/mity/md4c/issues/59):
545 |    Flag `MD_FLAG_NOHTMLSPANS` erroneously affected also recognition of
546 |    CommonMark autolinks.
547 | 
548 | 
549 | ## Version 0.3.0
550 | 
551 | New features:
552 | 
553 |  * Add extension for GitHub-style task lists:
554 | 
555 |    ```
556 |     * [x] foo
557 |     * [x] bar
558 |     * [ ] baz
559 |    ```
560 | 
561 |    (It has to be explicitly enabled with `MD_FLAG_TASKLISTS`.)
562 | 
563 |  * Added support for building as a shared library. On non-Windows platforms,
564 |    this is now default behavior; on Windows static library is still the default.
565 |    The CMake option `BUILD_SHARED_LIBS` can be used to request one or the other
566 |    explicitly.
567 | 
568 |    Contributed by Lisandro Damián Nicanor Pérez Meyer.
569 | 
570 |  * Renamed structure `MD_RENDERER` to `MD_PARSER` and refactorize its contents
571 |    a little bit. Note this is source-level incompatible and initialization code
572 |    in apps may need to be updated.
573 | 
574 |    The aim of the change is to be more friendly for long-term ABI compatibility
575 |    we shall maintain, starting with this release.
576 | 
577 |  * Added `CHANGELOG.md` (this file).
578 | 
579 |  * Make sure `md_process_table_row()` reports the same count of table cells for
580 |    all table rows, no matter how broken the input is. The cell count is derived
581 |    from table underline line. Bogus cells in other rows are silently ignored.
582 |    Missing cells in other rows are reported as empty ones.
583 | 
584 | Fixes:
585 | 
586 |  * CID 1475544:
587 |    Calling `md_free_attribute()` on uninitialized data.
588 | 
589 |  * [#47](https://github.com/mity/md4c/issues/47):
590 |    Using bad offsets in `md_is_entity_str()`, in some cases leading to buffer
591 |    overflow.
592 | 
593 |  * [#51](https://github.com/mity/md4c/issues/51):
594 |    Segfault in `md_process_table_cell()`.
595 | 
596 |  * [#53](https://github.com/mity/md4c/issues/53):
597 |    With `MD_FLAG_PERMISSIVEURLAUTOLINKS` or `MD_FLAG_PERMISSIVEWWWAUTOLINKS`
598 |    we could generate bad output for ordinary Markdown links, if a non-space
599 |    character immediately follows like e.g. in `[link](http://github.com)X`.
600 | 
601 | 
602 | ## Version 0.2.7
603 | 
604 | This was the last version before the changelog has been added.
605 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | cmake_minimum_required(VERSION 3.5)
 3 | project(MD4C C)
 4 | 
 5 | set(MD_VERSION_MAJOR 0)
 6 | set(MD_VERSION_MINOR 5)
 7 | set(MD_VERSION_RELEASE 2)
 8 | set(MD_VERSION "${MD_VERSION_MAJOR}.${MD_VERSION_MINOR}.${MD_VERSION_RELEASE}")
 9 | 
10 | set(PROJECT_VERSION "${MD_VERSION}")
11 | set(PROJECT_URL "https://github.com/mity/md4c")
12 | 
13 | 
14 | option(BUILD_MD2HTML_EXECUTABLE "Whether to compile the md2html executable" ON)
15 | 
16 | 
17 | if(WIN32)
18 |     # On Windows, given there is no standard lib install dir etc., we rather
19 |     # by default build static lib.
20 |     option(BUILD_SHARED_LIBS "help string describing option" OFF)
21 | else()
22 |     # On Linux, MD4C is slowly being adding into some distros which prefer
23 |     # shared lib.
24 |     option(BUILD_SHARED_LIBS "help string describing option" ON)
25 | endif()
26 | 
27 | add_definitions(
28 |     -DMD_VERSION_MAJOR=${MD_VERSION_MAJOR}
29 |     -DMD_VERSION_MINOR=${MD_VERSION_MINOR}
30 |     -DMD_VERSION_RELEASE=${MD_VERSION_RELEASE}
31 | )
32 | 
33 | set(CMAKE_CONFIGURATION_TYPES Debug Release RelWithDebInfo MinSizeRel)
34 | if("${CMAKE_BUILD_TYPE}" STREQUAL "")
35 |     set(CMAKE_BUILD_TYPE $ENV{CMAKE_BUILD_TYPE})
36 | 
37 |     if("${CMAKE_BUILD_TYPE}" STREQUAL "")
38 |         set(CMAKE_BUILD_TYPE "Release")
39 |     endif()
40 | endif()
41 | 
42 | 
43 | if(${CMAKE_C_COMPILER_ID} MATCHES GNU|Clang)
44 |     add_compile_options(-Wall -Wextra -Wshadow)
45 | 
46 |     # We enforce -Wdeclaration-after-statement because Qt project needs to
47 |     # build MD4C with Integrity compiler which chokes whenever a declaration
48 |     # is not at the beginning of a block.
49 |     add_compile_options(-Wdeclaration-after-statement)
50 | elseif(MSVC)
51 |     # Disable warnings about the so-called unsecured functions:
52 |     add_definitions(/D_CRT_SECURE_NO_WARNINGS)
53 |     add_compile_options(/W3)
54 | 
55 |     # Specify proper C runtime library:
56 |     string(REGEX REPLACE "/M[DT]d?" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
57 |     string(REGEX REPLACE "/M[DT]d?" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
58 |     string(REGEX REPLACE "/M[DT]d?" "" CMAKE_C_FLAGS_RELWITHDEBINFO "{$CMAKE_C_FLAGS_RELWITHDEBINFO}")
59 |     string(REGEX REPLACE "/M[DT]d?" "" CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}")
60 |     set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd")
61 |     set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT")
62 |     set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELEASE} /MT")
63 |     set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_RELEASE} /MT")
64 | endif()
65 | 
66 | include(GNUInstallDirs)
67 | 
68 | add_subdirectory(src)
69 | if (BUILD_MD2HTML_EXECUTABLE)
70 |     add_subdirectory(md2html)
71 | endif ()
72 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # The MIT License (MIT)
 3 | 
 4 | Copyright © 2016-2024 Martin Mitáš
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a
 7 | copy of this software and associated documentation files (the “Software”),
 8 | to deal in the Software without restriction, including without limitation
 9 | the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 | and/or sell copies of the Software, and to permit persons to whom the
11 | Software is furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included
14 | in all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 | OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 | THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
22 | IN THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # MD4C Readme
  3 | 
  4 | * Home: http://github.com/mity/md4c
  5 | * Wiki: http://github.com/mity/md4c/wiki
  6 | * Issue tracker: http://github.com/mity/md4c/issues
  7 | 
  8 | MD4C stands for "Markdown for C" and that's exactly what this project is about.
  9 | 
 10 | 
 11 | ## What is Markdown
 12 | 
 13 | In short, Markdown is the markup language this `README.md` file is written in.
 14 | 
 15 | The following resources can explain more if you are unfamiliar with it:
 16 | * [Wikipedia article](http://en.wikipedia.org/wiki/Markdown)
 17 | * [CommonMark site](http://commonmark.org)
 18 | 
 19 | 
 20 | ## What is MD4C
 21 | 
 22 | MD4C is Markdown parser implementation in C, with the following features:
 23 | 
 24 | * **Compliance:** Generally, MD4C aims to be compliant to the latest version of
 25 |   [CommonMark specification](http://spec.commonmark.org/). Currently, we are
 26 |   fully compliant to CommonMark 0.31.
 27 | 
 28 | * **Extensions:** MD4C supports some commonly requested and accepted extensions.
 29 |   See below.
 30 | 
 31 | * **Performance:** MD4C is [very fast](https://talk.commonmark.org/t/2520).
 32 | 
 33 | * **Compactness:** MD4C parser is implemented in one source file and one header
 34 |   file. There are no dependencies other than standard C library.
 35 | 
 36 | * **Embedding:** MD4C parser is easy to reuse in other projects, its API is
 37 |   very straightforward: There is actually just one function, `md_parse()`.
 38 | 
 39 | * **Push model:** MD4C parses the complete document and calls few callback
 40 |   functions provided by the application to inform it about a start/end of
 41 |   every block, a start/end of every span, and with any textual contents.
 42 | 
 43 | * **Portability:** MD4C builds and works on Windows and POSIX-compliant OSes.
 44 |   (It should be simple to make it run also on most other platforms, at least as
 45 |   long as the platform provides C standard library, including a heap memory
 46 |   management.)
 47 | 
 48 | * **Encoding:** MD4C by default expects UTF-8 encoding of the input document.
 49 |   But it can be compiled to recognize ASCII-only control characters (i.e. to
 50 |   disable all Unicode-specific code), or (on Windows) to expect UTF-16 (i.e.
 51 |   what is on Windows commonly called just "Unicode"). See more details below.
 52 | 
 53 | * **Permissive license:** MD4C is available under the [MIT license](LICENSE.md).
 54 | 
 55 | 
 56 | ## Using MD4C
 57 | 
 58 | ### Parsing Markdown
 59 | 
 60 | If you need just to parse a Markdown document, you need to include `md4c.h`
 61 | and link against MD4C library (`-lmd4c`); or alternatively add `md4c.[hc]`
 62 | directly to your code base as the parser is only implemented in the single C
 63 | source file.
 64 | 
 65 | The main provided function is `md_parse()`. It takes a text in the Markdown
 66 | syntax and a pointer to a structure which provides pointers to several callback
 67 | functions.
 68 | 
 69 | As `md_parse()` processes the input, it calls the callbacks (when entering or
 70 | leaving any Markdown block or span; and when outputting any textual content of
 71 | the document), allowing application to convert it into another format or render
 72 | it onto the screen.
 73 | 
 74 | 
 75 | ### Converting to HTML
 76 | 
 77 | If you need to convert Markdown to HTML, include `md4c-html.h` and link against
 78 | MD4C-HTML library (`-lmd4c-html`); or alternatively add the sources `md4c.[hc]`,
 79 | `md4c-html.[hc]` and `entity.[hc]` into your code base.
 80 | 
 81 | To convert a Markdown input, call `md_html()` function. It takes the Markdown
 82 | input and calls the provided callback function. The callback is fed with
 83 | chunks of the HTML output. Typical callback implementation just appends the
 84 | chunks into a buffer or writes them to a file.
 85 | 
 86 | 
 87 | ## Markdown Extensions
 88 | 
 89 | The default behavior is to recognize only Markdown syntax defined by the
 90 | [CommonMark specification](http://spec.commonmark.org/).
 91 | 
 92 | However, with appropriate flags, the behavior can be tuned to enable some
 93 | extensions:
 94 | 
 95 | * With the flag `MD_FLAG_COLLAPSEWHITESPACE`, a non-trivial whitespace is
 96 |   collapsed into a single space.
 97 | 
 98 | * With the flag `MD_FLAG_TABLES`, GitHub-style tables are supported.
 99 | 
100 | * With the flag `MD_FLAG_TASKLISTS`, GitHub-style task lists are supported.
101 | 
102 | * With the flag `MD_FLAG_STRIKETHROUGH`, strike-through spans are enabled
103 |   (text enclosed in tilde marks, e.g. `~foo bar~`).
104 | 
105 | * With the flag `MD_FLAG_PERMISSIVEURLAUTOLINKS` permissive URL autolinks
106 |   (not enclosed in `<` and `>`) are supported.
107 | 
108 | * With the flag `MD_FLAG_PERMISSIVEEMAILAUTOLINKS`, permissive e-mail
109 |   autolinks (not enclosed in `<` and `>`) are supported.
110 | 
111 | * With the flag `MD_FLAG_PERMISSIVEWWWAUTOLINKS` permissive WWW autolinks
112 |   without any scheme specified (e.g. `www.example.com`) are supported. MD4C
113 |   then assumes `http:` scheme.
114 | 
115 | * With the flag `MD_FLAG_LATEXMATHSPANS` LaTeX math spans (`$...$`) and
116 |   LaTeX display math spans (`$$...$$`) are supported. (Note though that the
117 |   HTML renderer outputs them verbatim in a custom tag `<x-equation>`.)
118 | 
119 | * With the flag `MD_FLAG_WIKILINKS`, wiki-style links (`[[link label]]` and
120 |   `[[target article|link label]]`) are supported. (Note that the HTML renderer
121 |   outputs them in a custom tag `<x-wikilink>`.)
122 | 
123 | * With the flag `MD_FLAG_UNDERLINE`, underscore (`_`) denotes an underline
124 |   instead of an ordinary emphasis or strong emphasis.
125 | 
126 | Few features of CommonMark (those some people see as mis-features) may be
127 | disabled with the following flags:
128 | 
129 | * With the flag `MD_FLAG_NOHTMLSPANS` or `MD_FLAG_NOHTMLBLOCKS`, raw inline
130 |   HTML or raw HTML blocks respectively are disabled.
131 | 
132 | * With the flag `MD_FLAG_NOINDENTEDCODEBLOCKS`, indented code blocks are
133 |   disabled.
134 | 
135 | 
136 | ## Input/Output Encoding
137 | 
138 | The CommonMark specification declares that any sequence of Unicode code points
139 | is a valid CommonMark document.
140 | 
141 | But, under a closer inspection, Unicode plays any role in few very specific
142 | situations when parsing Markdown documents:
143 | 
144 | 1. For detection of word boundaries when processing emphasis and strong
145 |    emphasis, some classification of Unicode characters (whether it is
146 |    a whitespace or a punctuation) is needed.
147 | 
148 | 2. For (case-insensitive) matching of a link reference label with the
149 |    corresponding link reference definition, Unicode case folding is used.
150 | 
151 | 3. For translating HTML entities (e.g. `&amp;`) and numeric character
152 |    references (e.g. `&#35;` or `&#xcab;`) into their Unicode equivalents.
153 | 
154 |    However note MD4C leaves this translation on the renderer/application; as
155 |    the renderer is supposed to really know output encoding and whether it
156 |    really needs to perform this kind of translation. (For example, when the
157 |    renderer outputs HTML, it may leave the entities untranslated and defer the
158 |    work to a web browser.)
159 | 
160 | MD4C relies on this property of the CommonMark and the implementation is, to
161 | a large degree, encoding-agnostic. Most of MD4C code only assumes that the
162 | encoding of your choice is compatible with ASCII. I.e. that the codepoints
163 | below 128 have the same numeric values as ASCII.
164 | 
165 | Any input MD4C does not understand is simply seen as part of the document text
166 | and sent to the renderer's callback functions unchanged.
167 | 
168 | The two situations (word boundary detection and link reference matching) where
169 | MD4C has to understand Unicode are handled as specified by the following
170 | preprocessor macros (as specified at the time MD4C is being built):
171 | 
172 | * If preprocessor macro `MD4C_USE_UTF8` is defined, MD4C assumes UTF-8 for the
173 |   word boundary detection and for the case-insensitive matching of link labels.
174 | 
175 |   When none of these macros is explicitly used, this is the default behavior.
176 | 
177 | * On Windows, if preprocessor macro `MD4C_USE_UTF16` is defined, MD4C uses
178 |   `WCHAR` instead of `char` and assumes UTF-16 encoding in those situations.
179 |   (UTF-16 is what Windows developers usually call just "Unicode" and what
180 |   Win32API generally works with.)
181 | 
182 |   Note that because this macro affects also the types in `md4c.h`, you have
183 |   to define the macro both when building MD4C as well as when including
184 |   `md4c.h`.
185 | 
186 |   Also note this is only supported in the parser (`md4c.[hc]`). The HTML
187 |   renderer does not support this and you will have to write your own custom
188 |   renderer to use this feature.
189 | 
190 | * If preprocessor macro `MD4C_USE_ASCII` is defined, MD4C assumes nothing but
191 |   an ASCII input.
192 | 
193 |   That effectively means that non-ASCII whitespace or punctuation characters
194 |   won't be recognized as such and that link reference matching will work in
195 |   a case-insensitive way only for ASCII letters (`[a-zA-Z]`).
196 | 
197 | 
198 | ## Documentation
199 | 
200 | The API of the parser is quite well documented in the comments in the `md4c.h`.
201 | Similarly, the markdown-to-html API is described in its header `md4c-html.h`.
202 | 
203 | There is also [project wiki](http://github.com/mity/md4c/wiki) which provides
204 | some more comprehensive documentation. However note it is incomplete and some
205 | details may be somewhat outdated.
206 | 
207 | 
208 | ## FAQ
209 | 
210 | **Q: How does MD4C compare to other Markdown parsers?**
211 | 
212 | **A:** Some other implementations combine Markdown parser and HTML generator
213 | into a single entangled code hidden behind an interface which just allows the
214 | conversion from Markdown to HTML. They are often unusable if you want to
215 | process the input in any other way.
216 | 
217 | Second, most parsers (if not all of them; at least within the scope of C/C++
218 | language) are full DOM-like parsers: They construct abstract syntax tree (AST)
219 | representation of the whole Markdown document. That takes time and it leads to
220 | bigger memory footprint.
221 | 
222 | Building AST is completely fine as long as you need it. If you don't, there is
223 | a very high chance that using MD4C will be substantially faster and less hungry
224 | in terms of memory consumption.
225 | 
226 | Last but not least, some Markdown parsers are implemented in a naive way. When
227 | fed with a [smartly crafted input pattern](test/pathological_tests.py), they
228 | may exhibit quadratic (or even worse) parsing times. What MD4C can still parse
229 | in a fraction of second may turn into long minutes or possibly hours with them.
230 | Hence, when such a naive parser is used to process an input from an untrusted
231 | source, the possibility of denial-of-service attacks becomes a real danger.
232 | 
233 | A lot of our effort went into providing linear parsing times no matter what
234 | kind of crazy input MD4C parser is fed with. (If you encounter an input pattern
235 | which leads to a sub-linear parsing times, please do not hesitate and report it
236 | as a bug.)
237 | 
238 | **Q: Does MD4C perform any input validation?**
239 | 
240 | **A:** No. And we are proud of it. :-)
241 | 
242 | CommonMark specification states that any sequence of Unicode characters is
243 | a valid Markdown document. (In practice, this more or less always means UTF-8
244 | encoding.)
245 | 
246 | In other words, according to the specification, it does not matter whether some
247 | Markdown syntax construction is in some way broken or not. If it's broken, it
248 | won't be recognized and the parser should see it just as a verbatim text.
249 | 
250 | MD4C takes this a step further: It sees any sequence of bytes as a valid input,
251 | following completely the GIGO philosophy (garbage in, garbage out). I.e. any
252 | ill-formed UTF-8 byte sequence will propagate to the respective callback as
253 | a part of the text.
254 | 
255 | If you need to validate that the input is, say, a well-formed UTF-8 document,
256 | you have to do it on your own. The easiest way how to do this is to simply
257 | validate the whole document before passing it to the MD4C parser.
258 | 
259 | 
260 | ## License
261 | 
262 | MD4C is covered with MIT license, see the file `LICENSE.md`.
263 | 
264 | 
265 | ## Links to Related Projects
266 | 
267 | Ports and bindings to other languages:
268 | 
269 | * [commonmark-d](https://github.com/AuburnSounds/commonmark-d):
270 |   Port of MD4C to D language.
271 | 
272 | * [markdown-wasm](https://github.com/rsms/markdown-wasm):
273 |   Port of MD4C to WebAssembly.
274 | 
275 | * [PyMD4C](https://github.com/dominickpastore/pymd4c):
276 |   Python bindings for MD4C
277 | 
278 | Software using MD4C:
279 | 
280 | * [imgui_md](https://github.com/mekhontsev/imgui_md):
281 |   Markdown renderer for [Dear ImGui](https://github.com/ocornut/imgui)
282 | 
283 | * [MarkDown Monolith Assembler](https://github.com/1Hyena/mdma):
284 |   A command line tool for building browser-based books.
285 | 
286 | * [QOwnNotes](https://www.qownnotes.org/):
287 |   A plain-text file notepad and todo-list manager with markdown support and
288 |   ownCloud / Nextcloud integration.
289 | 
290 | * [Qt](https://www.qt.io/):
291 |   Cross-platform C++ GUI framework.
292 | 
293 | * [Textosaurus](https://github.com/martinrotter/textosaurus):
294 |   Cross-platform text editor based on Qt and Scintilla.
295 | 
296 | * [8th](https://8th-dev.com/):
297 |   Cross-platform concatenative programming language.
298 | 


--------------------------------------------------------------------------------
/md2html/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG")
 3 | 
 4 | 
 5 | # Build rules for md2html command line utility
 6 | 
 7 | include_directories("${PROJECT_SOURCE_DIR}/src")
 8 | add_executable(md2html cmdline.c cmdline.h md2html.c)
 9 | target_link_libraries(md2html md4c-html)
10 | 
11 | 
12 | # Install rules
13 | 
14 | install(
15 |     TARGETS md2html
16 |     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
17 |     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
18 |     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
19 |     PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
20 | )
21 | install(FILES "md2html.1" DESTINATION "${CMAKE_INSTALL_MANDIR}/man1")
22 | 
23 | 


--------------------------------------------------------------------------------
/md2html/cmdline.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * C Reusables
  3 |  * <http://github.com/mity/c-reusables>
  4 |  *
  5 |  * Copyright (c) 2017-2020 Martin Mitáš
  6 |  *
  7 |  * Permission is hereby granted, free of charge, to any person obtaining a
  8 |  * copy of this software and associated documentation files (the "Software"),
  9 |  * to deal in the Software without restriction, including without limitation
 10 |  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 11 |  * and/or sell copies of the Software, and to permit persons to whom the
 12 |  * Software is furnished to do so, subject to the following conditions:
 13 |  *
 14 |  * The above copyright notice and this permission notice shall be included in
 15 |  * all copies or substantial portions of the Software.
 16 |  *
 17 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 18 |  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 19 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 20 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 21 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 22 |  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 23 |  * IN THE SOFTWARE.
 24 |  */
 25 | 
 26 | #include "cmdline.h"
 27 | 
 28 | #include <stdio.h>
 29 | #include <string.h>
 30 | 
 31 | 
 32 | #ifdef _WIN32
 33 |     #define snprintf    _snprintf
 34 | #endif
 35 | 
 36 | 
 37 | #define CMDLINE_AUXBUF_SIZE     32
 38 | 
 39 | 
 40 | 
 41 | static int
 42 | cmdline_handle_short_opt_group(const CMDLINE_OPTION* options, const char* arggroup,
 43 |         int (*callback)(int /*optval*/, const char* /*arg*/, void* /*userdata*/),
 44 |         void* userdata)
 45 | {
 46 |     const CMDLINE_OPTION* opt;
 47 |     int i;
 48 |     int ret = 0;
 49 | 
 50 |     for(i = 0; arggroup[i] != '\0'; i++) {
 51 |         for(opt = options; opt->id != 0; opt++) {
 52 |             if(arggroup[i] == opt->shortname)
 53 |                 break;
 54 |         }
 55 | 
 56 |         if(opt->id != 0  &&  !(opt->flags & CMDLINE_OPTFLAG_REQUIREDARG)) {
 57 |             ret = callback(opt->id, NULL, userdata);
 58 |         } else {
 59 |             /* Unknown option. */
 60 |             char badoptname[3];
 61 |             badoptname[0] = '-';
 62 |             badoptname[1] = arggroup[i];
 63 |             badoptname[2] = '\0';
 64 |             ret = callback((opt->id != 0 ? CMDLINE_OPTID_MISSINGARG : CMDLINE_OPTID_UNKNOWN),
 65 |                             badoptname, userdata);
 66 |         }
 67 | 
 68 |         if(ret != 0)
 69 |             break;
 70 |     }
 71 | 
 72 |     return ret;
 73 | }
 74 | 
 75 | int
 76 | cmdline_read(const CMDLINE_OPTION* options, int argc, char** argv,
 77 |         int (*callback)(int /*optval*/, const char* /*arg*/, void* /*userdata*/),
 78 |         void* userdata)
 79 | {
 80 |     const CMDLINE_OPTION* opt;
 81 |     char auxbuf[CMDLINE_AUXBUF_SIZE+1];
 82 |     int fast_optarg_decision = 1;
 83 |     int after_doubledash = 0;
 84 |     int i = 1;
 85 |     int ret = 0;
 86 | 
 87 |     auxbuf[CMDLINE_AUXBUF_SIZE] = '\0';
 88 | 
 89 |     /* Check whether there is any CMDLINE_OPTFLAG_COMPILERLIKE option with
 90 |      * a name not starting with '-'. That would imply we can to check for
 91 |      * non-option arguments only after refusing all such options. */
 92 |     for(opt = options; opt->id != 0; opt++) {
 93 |         if((opt->flags & CMDLINE_OPTFLAG_COMPILERLIKE)  &&  opt->longname[0] != '-')
 94 |             fast_optarg_decision = 0;
 95 |     }
 96 | 
 97 |     while(i < argc) {
 98 |         if(after_doubledash  ||  strcmp(argv[i], "-") == 0) {
 99 |             /* Non-option argument.
100 |              * Standalone "-" usually means "read from stdin" or "write to
101 |              * stdout" so treat it always as a non-option. */
102 |             ret = callback(CMDLINE_OPTID_NONE, argv[i], userdata);
103 |         } else if(strcmp(argv[i], "--") == 0) {
104 |             /* End of options. All the remaining tokens are non-options
105 |              * even if they start with a dash. */
106 |             after_doubledash = 1;
107 |         } else if(fast_optarg_decision  &&  argv[i][0] != '-') {
108 |             /* Non-option argument. */
109 |             ret = callback(CMDLINE_OPTID_NONE, argv[i], userdata);
110 |         } else {
111 |             for(opt = options; opt->id != 0; opt++) {
112 |                 if(opt->flags & CMDLINE_OPTFLAG_COMPILERLIKE) {
113 |                     size_t len = strlen(opt->longname);
114 |                     if(strncmp(argv[i], opt->longname, len) == 0) {
115 |                         /* Compiler-like option. */
116 |                         if(argv[i][len] != '\0')
117 |                             ret = callback(opt->id, argv[i] + len, userdata);
118 |                         else if(i+1 < argc)
119 |                             ret = callback(opt->id, argv[++i], userdata);
120 |                         else
121 |                             ret = callback(CMDLINE_OPTID_MISSINGARG, opt->longname, userdata);
122 |                         break;
123 |                     }
124 |                 } else if(opt->longname != NULL  &&  strncmp(argv[i], "--", 2) == 0) {
125 |                     size_t len = strlen(opt->longname);
126 |                     if(strncmp(argv[i]+2, opt->longname, len) == 0) {
127 |                         /* Regular long option. */
128 |                         if(argv[i][2+len] == '\0') {
129 |                             /* with no argument provided. */
130 |                             if(!(opt->flags & CMDLINE_OPTFLAG_REQUIREDARG))
131 |                                 ret = callback(opt->id, NULL, userdata);
132 |                             else
133 |                                 ret = callback(CMDLINE_OPTID_MISSINGARG, argv[i], userdata);
134 |                             break;
135 |                         } else if(argv[i][2+len] == '=') {
136 |                             /* with an argument provided. */
137 |                             if(opt->flags & (CMDLINE_OPTFLAG_OPTIONALARG | CMDLINE_OPTFLAG_REQUIREDARG)) {
138 |                                 ret = callback(opt->id, argv[i]+2+len+1, userdata);
139 |                             } else {
140 |                                 snprintf(auxbuf, CMDLINE_AUXBUF_SIZE, "--%s", opt->longname);
141 |                                 ret = callback(CMDLINE_OPTID_BOGUSARG, auxbuf, userdata);
142 |                             }
143 |                             break;
144 |                         } else {
145 |                             continue;
146 |                         }
147 |                     }
148 |                 } else if(opt->shortname != '\0'  &&  argv[i][0] == '-') {
149 |                     if(argv[i][1] == opt->shortname) {
150 |                         /* Regular short option. */
151 |                         if(opt->flags & CMDLINE_OPTFLAG_REQUIREDARG) {
152 |                             if(argv[i][2] != '\0')
153 |                                 ret = callback(opt->id, argv[i]+2, userdata);
154 |                             else if(i+1 < argc)
155 |                                 ret = callback(opt->id, argv[++i], userdata);
156 |                             else
157 |                                 ret = callback(CMDLINE_OPTID_MISSINGARG, argv[i], userdata);
158 |                             break;
159 |                         } else {
160 |                             ret = callback(opt->id, NULL, userdata);
161 | 
162 |                             /* There might be more (argument-less) short options
163 |                              * grouped together. */
164 |                             if(ret == 0  &&  argv[i][2] != '\0')
165 |                                 ret = cmdline_handle_short_opt_group(options, argv[i]+2, callback, userdata);
166 |                             break;
167 |                         }
168 |                     }
169 |                 }
170 |             }
171 | 
172 |             if(opt->id == 0) {  /* still not handled? */
173 |                 if(argv[i][0] != '-') {
174 |                     /* Non-option argument. */
175 |                     ret = callback(CMDLINE_OPTID_NONE, argv[i], userdata);
176 |                 } else {
177 |                     /* Unknown option. */
178 |                     char* badoptname = argv[i];
179 | 
180 |                     if(strncmp(badoptname, "--", 2) == 0) {
181 |                         /* Strip any argument from the long option. */
182 |                         char* assignment = strchr(badoptname, '=');
183 |                         if(assignment != NULL) {
184 |                             size_t len = assignment - badoptname;
185 |                             if(len > CMDLINE_AUXBUF_SIZE)
186 |                                 len = CMDLINE_AUXBUF_SIZE;
187 |                             strncpy(auxbuf, badoptname, len);
188 |                             auxbuf[len] = '\0';
189 |                             badoptname = auxbuf;
190 |                         }
191 |                     }
192 | 
193 |                     ret = callback(CMDLINE_OPTID_UNKNOWN, badoptname, userdata);
194 |                 }
195 |             }
196 |         }
197 | 
198 |         if(ret != 0)
199 |             return ret;
200 |         i++;
201 |     }
202 | 
203 |     return ret;
204 | }
205 | 
206 | 


--------------------------------------------------------------------------------
/md2html/cmdline.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * C Reusables
  3 |  * <http://github.com/mity/c-reusables>
  4 |  *
  5 |  * Copyright (c) 2017 Martin Mitáš
  6 |  *
  7 |  * Permission is hereby granted, free of charge, to any person obtaining a
  8 |  * copy of this software and associated documentation files (the "Software"),
  9 |  * to deal in the Software without restriction, including without limitation
 10 |  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 11 |  * and/or sell copies of the Software, and to permit persons to whom the
 12 |  * Software is furnished to do so, subject to the following conditions:
 13 |  *
 14 |  * The above copyright notice and this permission notice shall be included in
 15 |  * all copies or substantial portions of the Software.
 16 |  *
 17 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 18 |  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 19 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 20 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 21 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 22 |  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 23 |  * IN THE SOFTWARE.
 24 |  */
 25 | 
 26 | #ifndef CRE_CMDLINE_H
 27 | #define CRE_CMDLINE_H
 28 | 
 29 | #ifdef __cplusplus
 30 | extern "C" {
 31 | #endif
 32 | 
 33 | 
 34 | /* The option may have an argument. (Affects only long option.) */
 35 | #define CMDLINE_OPTFLAG_OPTIONALARG     0x0001
 36 | 
 37 | /* The option must have an argument.
 38 |  * Such short option cannot be grouped within single '-abc'. */
 39 | #define CMDLINE_OPTFLAG_REQUIREDARG     0x0002
 40 | 
 41 | /* Enable special compiler-like mode for the long option.
 42 |  *
 43 |  * Note ::shortname is not supported with this flag. CMDLINE_OPTION::shortname
 44 |  * is silently ignored if the flag is used.
 45 |  *
 46 |  * With this flag, CMDLINE_OPTION::longname is treated differently as follows:
 47 |  *
 48 |  * 1. The option matches if the CMDLINE_OPTION::longname is the exact prefix
 49 |  *    of the argv[i] from commandline.
 50 |  *
 51 |  * 2. Double dash ("--") is not automatically prepended to
 52 |  *    CMDLINE_OPTION::longname. (If you desire any leading dash, include it
 53 |  *    explicitly in CMDLINE_OPTION initialization.)
 54 |  *
 55 |  * 3. An argument is required (the flag CMDLINE_OPTFLAG_COMPILERLIKE implicitly
 56 |  *    implies also the flag CMDLINE_OPTFLAG_REQUIREDARG).
 57 |  *
 58 |  *    But there is no "=" delimiter expected between the option and argument,
 59 |  *    however there is an optional whitespace allowed.
 60 |  *
 61 |  *    This offers similar semantics to common compiler options. For example:
 62 |  *      -DDEBUG=0               (If -D is the option, DEBUG=0 is the argument)
 63 |  *      -Isrc/include           (If -I is the option, src/include is the argument)
 64 |  *      -I src/include          (Equivalent to the above)
 65 |  *      -isystem /usr/include   (If -isystem is the option, /usr/include is the argument)
 66 |  *      -lmath                  (If -l is the option, math is the argument)
 67 |  */
 68 | #define CMDLINE_OPTFLAG_COMPILERLIKE    0x0004
 69 | 
 70 | 
 71 | /* Special (reserved) option IDs. Do not use these for any CMDLINE_OPTION::id.
 72 |  * See documentation of cmdline_read() to get info about their meaning.
 73 |  */
 74 | #define CMDLINE_OPTID_NONE              0
 75 | #define CMDLINE_OPTID_UNKNOWN           (-0x7fffffff + 0)
 76 | #define CMDLINE_OPTID_MISSINGARG        (-0x7fffffff + 1)
 77 | #define CMDLINE_OPTID_BOGUSARG          (-0x7fffffff + 2)
 78 | 
 79 | 
 80 | typedef struct CMDLINE_OPTION {
 81 |     char shortname;         /* Short (single char) option or 0. */
 82 |     const char* longname;   /* Long name (after "--") or NULL. */
 83 |     int id;                 /* Non-zero ID to identify the option in the callback; or zero to denote end of options list. */
 84 |     unsigned flags;         /* Bitmask of CMDLINE_OPTFLAG_xxxx flags. */
 85 | } CMDLINE_OPTION;
 86 | 
 87 | 
 88 | /* Parses all options and their arguments as specified by argc, argv accordingly
 89 |  * with the given options (except argv[0] which is ignored).
 90 |  *
 91 |  * The caller must specify the list of supported options in the 1st parameter
 92 |  * of the function. The array must end with a record whose CMDLINE_OPTION::id
 93 |  * is set to zero.
 94 |  *
 95 |  * The provided callback function is called for each option on the command
 96 |  * line so that:
 97 |  *
 98 |  *   -- the "id" refers to the id of the option as specified in options[].
 99 |  *
100 |  *   -- the "arg" specifies an argument of the option or NULL if none is
101 |  *      provided.
102 |  *
103 |  *   -- the "userdata" just allows to pass in some caller's context into
104 |  *      the callback.
105 |  *
106 |  * Special cases (recognized via special "id" value) are reported to the
107 |  * callback as follows:
108 |  *
109 |  *   -- If id is CMDLINE_OPTID_NONE, the callback informs about a non-option,
110 |  *      also known as a positional argument.
111 |  *
112 |  *      All argv[] tokens which are not interpreted as an options or an argument
113 |  *      of any option fall into this category.
114 |  *
115 |  *      Usually, programs interpret these as file paths to process.
116 |  *
117 |  *   -- If id is CMDLINE_OPTID_UNKNOWN, the corresponding argv[] looks like an
118 |  *      option but it is not found in the options[] passed to cmdline_read().
119 |  *
120 |  *      The callback's parameter arg specifies the guilty command line token.
121 |  *      Usually, program writes down an error message and exits.
122 |  *
123 |  *   -- If id is CMDLINE_OPTID_MISSINGARG, the given option is valid but its
124 |  *      flag in options[] requires an argument; yet there is none on the
125 |  *      command line.
126 |  *
127 |  *      The callback's parameter arg specifies the guilty option name.
128 |  *      Usually, program writes down an error message and exits.
129 |  *
130 |  *   -- If id is CMDLINE_OPTID_BOGUSARG, the given option is valid but its
131 |  *      flag in options[] does not expect an argument; yet the command line
132 |  *      does provide one.
133 |  *
134 |  *      The callback's parameter arg specifies the guilty option name.
135 |  *      Usually, program writes down an error message and exits.
136 |  *
137 |  * On success, zero is returned.
138 |  *
139 |  * If the callback returns a non-zero, cmdline_read() aborts immediately and
140 |  * cmdline_read() propagates the same return value to the caller.
141 |  */
142 | 
143 | int cmdline_read(const CMDLINE_OPTION* options, int argc, char** argv,
144 |         int (*callback)(int /*id*/, const char* /*arg*/, void* /*userdata*/),
145 |         void* userdata);
146 | 
147 | 
148 | #ifdef __cplusplus
149 | }  /* extern "C" { */
150 | #endif
151 | 
152 | #endif  /* CRE_CMDLINE_H */
153 | 


--------------------------------------------------------------------------------
/md2html/md2html.1:
--------------------------------------------------------------------------------
  1 | .TH MD2HTML 1 "June 2019" "" "General Commands Manual"
  2 | .nh
  3 | .ad l
  4 | .
  5 | .SH NAME
  6 | .
  7 | md2html \- convert Markdown to HTML
  8 | .
  9 | .SH SYNOPSIS
 10 | .
 11 | .B md2html
 12 | .RI [ OPTION ]...\&
 13 | .RI [ FILE ]
 14 | .
 15 | .SH OPTIONS
 16 | .
 17 | .SS General options:
 18 | .
 19 | .TP
 20 | .BR -o ", " --output= \fIOUTFILE\fR
 21 | Write output to \fIOUTFILE\fR instead of \fBstdout\fR(3)
 22 | .
 23 | .TP
 24 | .BR -f ", " --full-html
 25 | Generate full HTML document, including header
 26 | .
 27 | .TP
 28 | .BR -s ", " --stat
 29 | Measure time of input parsing
 30 | .
 31 | .TP
 32 | .BR -h ", " --help
 33 | Display help and exit
 34 | .
 35 | .TP
 36 | .BR -v ", " --version
 37 | Display version and exit
 38 | .
 39 | .SS Markdown dialect options:
 40 | .
 41 | .TP
 42 | .B --commonmark
 43 | CommonMark (the default)
 44 | .
 45 | .TP
 46 | .B --github
 47 | Github Flavored Markdown
 48 | .
 49 | .PP
 50 | Note: dialect options are equivalent to some combination of flags below.
 51 | .
 52 | .SS Markdown extension options:
 53 | .
 54 | .TP
 55 | .B --fcollapse-whitespace
 56 | Collapse non-trivial whitespace
 57 | .
 58 | .TP
 59 | .B --fverbatim-entities
 60 | Do not translate entities
 61 | .
 62 | .TP
 63 | .B --fpermissive-atx-headers
 64 | Allow ATX headers without delimiting space
 65 | .
 66 | .TP
 67 | .B --fpermissive-url-autolinks
 68 | Allow URL autolinks without "<" and ">" delimiters
 69 | .
 70 | .TP
 71 | .B --fpermissive-www-autolinks
 72 | Allow WWW autolinks without any scheme (e.g. "www.example.com")
 73 | .
 74 | .TP
 75 | .B --fpermissive-email-autolinks
 76 | Allow e-mail autolinks without "<", ">" and "mailto:"
 77 | .
 78 | .TP
 79 | .B --fpermissive-autolinks
 80 | Enable all 3 of the above permissive autolinks options
 81 | .TP
 82 | .B --fhard-soft-breaks
 83 | Force all soft breaks to act as hard breaks
 84 | .
 85 | .TP
 86 | .B --fno-indented-code
 87 | Disable indented code blocks
 88 | .
 89 | .TP
 90 | .B --fno-html-blocks
 91 | Disable raw HTML blocks
 92 | .
 93 | .TP
 94 | .B --fno-html-spans
 95 | Disable raw HTML spans
 96 | .
 97 | .TP
 98 | .B --fno-html
 99 | Same as \fB--fno-html-blocks --fno-html-spans\fR
100 | .
101 | .TP
102 | .B --ftables
103 | Enable tables
104 | .
105 | .TP
106 | .B --fstrikethrough
107 | Enable strikethrough spans
108 | .
109 | .TP
110 | .B --ftasklists
111 | Enable task lists
112 | .
113 | .SH SEE ALSO
114 | .
115 | https://github.com/mity/md4c
116 | .
117 | 


--------------------------------------------------------------------------------
/md2html/md2html.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * MD4C: Markdown parser for C
  3 |  * (http://github.com/mity/md4c)
  4 |  *
  5 |  * Copyright (c) 2016-2024 Martin Mitáš
  6 |  *
  7 |  * Permission is hereby granted, free of charge, to any person obtaining a
  8 |  * copy of this software and associated documentation files (the "Software"),
  9 |  * to deal in the Software without restriction, including without limitation
 10 |  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 11 |  * and/or sell copies of the Software, and to permit persons to whom the
 12 |  * Software is furnished to do so, subject to the following conditions:
 13 |  *
 14 |  * The above copyright notice and this permission notice shall be included in
 15 |  * all copies or substantial portions of the Software.
 16 |  *
 17 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 18 |  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 19 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 20 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 21 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 22 |  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 23 |  * IN THE SOFTWARE.
 24 |  */
 25 | 
 26 | #include <stdio.h>
 27 | #include <stdlib.h>
 28 | #include <string.h>
 29 | #include <time.h>
 30 | 
 31 | #include "md4c-html.h"
 32 | #include "cmdline.h"
 33 | 
 34 | 
 35 | 
 36 | /* Global options. */
 37 | static unsigned parser_flags = 0;
 38 | #ifndef MD4C_USE_ASCII
 39 |     static unsigned renderer_flags = MD_HTML_FLAG_DEBUG | MD_HTML_FLAG_SKIP_UTF8_BOM;
 40 | #else
 41 |     static unsigned renderer_flags = MD_HTML_FLAG_DEBUG;
 42 | #endif
 43 | static int want_fullhtml = 0;
 44 | static int want_xhtml = 0;
 45 | static int want_stat = 0;
 46 | static int want_replay_fuzz = 0;
 47 | 
 48 | static const char* html_title = NULL;
 49 | static const char* css_path = NULL;
 50 | 
 51 | 
 52 | /*********************************
 53 |  ***  Simple grow-able buffer  ***
 54 |  *********************************/
 55 | 
 56 | /* We render to a memory buffer instead of directly outputting the rendered
 57 |  * documents, as this allows using this utility for evaluating performance
 58 |  * of MD4C (--stat option). This allows us to measure just time of the parser,
 59 |  * without the I/O.
 60 |  */
 61 | 
 62 | struct membuffer {
 63 |     char* data;
 64 |     size_t asize;
 65 |     size_t size;
 66 | };
 67 | 
 68 | static void
 69 | membuf_init(struct membuffer* buf, MD_SIZE new_asize)
 70 | {
 71 |     buf->size = 0;
 72 |     buf->asize = new_asize;
 73 |     buf->data = malloc(buf->asize);
 74 |     if(buf->data == NULL) {
 75 |         fprintf(stderr, "membuf_init: malloc() failed.\n");
 76 |         exit(1);
 77 |     }
 78 | }
 79 | 
 80 | static void
 81 | membuf_fini(struct membuffer* buf)
 82 | {
 83 |     if(buf->data)
 84 |         free(buf->data);
 85 | }
 86 | 
 87 | static void
 88 | membuf_grow(struct membuffer* buf, size_t new_asize)
 89 | {
 90 |     buf->data = realloc(buf->data, new_asize);
 91 |     if(buf->data == NULL) {
 92 |         fprintf(stderr, "membuf_grow: realloc() failed.\n");
 93 |         exit(1);
 94 |     }
 95 |     buf->asize = new_asize;
 96 | }
 97 | 
 98 | static void
 99 | membuf_append(struct membuffer* buf, const char* data, MD_SIZE size)
100 | {
101 |     if(buf->asize < buf->size + size)
102 |         membuf_grow(buf, buf->size + buf->size / 2 + size);
103 |     memcpy(buf->data + buf->size, data, size);
104 |     buf->size += size;
105 | }
106 | 
107 | 
108 | /**********************
109 |  ***  Main program  ***
110 |  **********************/
111 | 
112 | static void
113 | process_output(const MD_CHAR* text, MD_SIZE size, void* userdata)
114 | {
115 |     membuf_append((struct membuffer*) userdata, text, size);
116 | }
117 | 
118 | static int
119 | process_file(const char* in_path, FILE* in, FILE* out)
120 | {
121 |     size_t n;
122 |     struct membuffer buf_in = {0};
123 |     struct membuffer buf_out = {0};
124 |     int ret = -1;
125 |     clock_t t0, t1;
126 |     unsigned p_flags = parser_flags;
127 |     unsigned r_flags = renderer_flags;
128 | 
129 |     membuf_init(&buf_in, 32 * 1024);
130 | 
131 |     /* Read the input file into a buffer. */
132 |     while(1) {
133 |         if(buf_in.size >= buf_in.asize)
134 |             membuf_grow(&buf_in, buf_in.asize + buf_in.asize / 2);
135 | 
136 |         n = fread(buf_in.data + buf_in.size, 1, buf_in.asize - buf_in.size, in);
137 |         if(n == 0)
138 |             break;
139 |         buf_in.size += n;
140 |     }
141 | 
142 |     /* Input size is good estimation of output size. Add some more reserve to
143 |      * deal with the HTML header/footer and tags. */
144 |     membuf_init(&buf_out, (MD_SIZE)(buf_in.size + buf_in.size/8 + 64));
145 | 
146 |     /* Special mode for reproduce test case found with fuzzing a tool.
147 |      * We assume file format as produced by test/fuzzers/fuzz-mdhtml.c. */
148 |     if(want_replay_fuzz) {
149 |         if(buf_in.size < 2 * sizeof(unsigned)) {
150 |             fprintf(stderr, "File %s isn't valid fuzz test case.\n", in_path);
151 |             ret = -1;
152 |             goto out;
153 |         }
154 | 
155 |         /* Override parser and renderer flags with those form the test case. */
156 |         p_flags = ((unsigned*)buf_in.data)[0];
157 |         r_flags = ((unsigned*)buf_in.data)[1];
158 | 
159 |         /* And get rid of them from the text input to the parser. */
160 |         memmove(buf_in.data, buf_in.data + 2 * sizeof(unsigned),
161 |                     buf_in.size - 2 * sizeof(unsigned));
162 |         buf_in.size -= 2 * sizeof(unsigned);
163 | 
164 |         /* Zero the tail we have moved the contents from.
165 |          * It helps in debugging if make it actually a zero-terminated string. */
166 |         memset(buf_in.data + buf_in.size, 0, 2 * sizeof(unsigned));
167 |     }
168 | 
169 |     /* Parse the document. This shall call our callbacks provided via the
170 |      * md_renderer_t structure. */
171 |     t0 = clock();
172 | 
173 |     ret = md_html(buf_in.data, (MD_SIZE)buf_in.size, process_output,
174 |                 (void*) &buf_out, p_flags, r_flags);
175 | 
176 |     t1 = clock();
177 |     if(ret != 0) {
178 |         fprintf(stderr, "Parsing failed.\n");
179 |         goto out;
180 |     }
181 | 
182 |     /* Write down the document in the HTML format. */
183 |     if(want_fullhtml) {
184 |         if(want_xhtml) {
185 |             fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
186 |             fprintf(out, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" "
187 |                             "\"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">\n");
188 |             fprintf(out, "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n");
189 |         } else {
190 |             fprintf(out, "<!DOCTYPE html>\n");
191 |             fprintf(out, "<html>\n");
192 |         }
193 |         fprintf(out, "<head>\n");
194 |         fprintf(out, "<title>%s</title>\n", html_title ? html_title : "");
195 |         fprintf(out, "<meta name=\"generator\" content=\"md2html\"%s>\n", want_xhtml ? " /" : "");
196 | #if !defined MD4C_USE_ASCII && !defined MD4C_USE_UTF16
197 |         fprintf(out, "<meta charset=\"UTF-8\"%s>\n", want_xhtml ? " /" : "");
198 | #endif
199 |         if(css_path != NULL) {
200 |             fprintf(out, "<link rel=\"stylesheet\" href=\"%s\"%s>\n", css_path, want_xhtml ? " /" : "");
201 |         }
202 |         fprintf(out, "</head>\n");
203 |         fprintf(out, "<body>\n");
204 |     }
205 | 
206 |     fwrite(buf_out.data, 1, buf_out.size, out);
207 | 
208 |     if(want_fullhtml) {
209 |         fprintf(out, "</body>\n");
210 |         fprintf(out, "</html>\n");
211 |     }
212 | 
213 |     if(want_stat) {
214 |         if(t0 != (clock_t)-1  &&  t1 != (clock_t)-1) {
215 |             double elapsed = (double)(t1 - t0) / CLOCKS_PER_SEC;
216 |             if (elapsed < 1)
217 |                 fprintf(stderr, "Time spent on parsing: %7.2f ms.\n", elapsed*1e3);
218 |             else
219 |                 fprintf(stderr, "Time spent on parsing: %6.3f s.\n", elapsed);
220 |         }
221 |     }
222 | 
223 |     /* Success if we have reached here. */
224 |     ret = 0;
225 | 
226 | out:
227 |     membuf_fini(&buf_in);
228 |     membuf_fini(&buf_out);
229 | 
230 |     return ret;
231 | }
232 | 
233 | 
234 | static const CMDLINE_OPTION cmdline_options[] = {
235 |     { 'o', "output",                        'o', CMDLINE_OPTFLAG_REQUIREDARG },
236 |     { 'f', "full-html",                     'f', 0 },
237 |     { 'x', "xhtml",                         'x', 0 },
238 |     { 's', "stat",                          's', 0 },
239 |     { 'h', "help",                          'h', 0 },
240 |     { 'v', "version",                       'v', 0 },
241 | 
242 |     {  0,  "html-title",                    '1', CMDLINE_OPTFLAG_REQUIREDARG },
243 |     {  0,  "html-css",                      '2', CMDLINE_OPTFLAG_REQUIREDARG },
244 | 
245 |     {  0,  "commonmark",                    'c', 0 },
246 |     {  0,  "github",                        'g', 0 },
247 | 
248 |     {  0,  "fcollapse-whitespace",          'W', 0 },
249 |     {  0,  "flatex-math",                   'L', 0 },
250 |     {  0,  "fpermissive-atx-headers",       'A', 0 },
251 |     {  0,  "fpermissive-autolinks",         'V', 0 },
252 |     {  0,  "fhard-soft-breaks",             'B', 0 },
253 |     {  0,  "fpermissive-email-autolinks",   '@', 0 },
254 |     {  0,  "fpermissive-url-autolinks",     'U', 0 },
255 |     {  0,  "fpermissive-www-autolinks",     '.', 0 },
256 |     {  0,  "fstrikethrough",                'S', 0 },
257 |     {  0,  "ftables",                       'T', 0 },
258 |     {  0,  "ftasklists",                    'X', 0 },
259 |     {  0,  "funderline",                    '_', 0 },
260 |     {  0,  "fverbatim-entities",            'E', 0 },
261 |     {  0,  "fwiki-links",                   'K', 0 },
262 | 
263 |     {  0,  "fno-html-blocks",               'F', 0 },
264 |     {  0,  "fno-html-spans",                'G', 0 },
265 |     {  0,  "fno-html",                      'H', 0 },
266 |     {  0,  "fno-indented-code",             'I', 0 },
267 | 
268 |     /* Undocumented option for replaying test cases from fuzzers. */
269 |     {  0,  "replay-fuzz",                   'r', 0 },
270 | 
271 |     {  0,  NULL,                             0,  0 }
272 | };
273 | 
274 | static void
275 | usage(void)
276 | {
277 |     printf(
278 |         "Usage: md2html [OPTION]... [FILE]\n"
279 |         "Convert input FILE (or standard input) in Markdown format to HTML.\n"
280 |         "\n"
281 |         "General options:\n"
282 |         "  -o  --output=FILE    Output file (default is standard output)\n"
283 |         "  -f, --full-html      Generate full HTML document, including header\n"
284 |         "  -x, --xhtml          Generate XHTML instead of HTML\n"
285 |         "  -s, --stat           Measure time of input parsing\n"
286 |         "  -h, --help           Display this help and exit\n"
287 |         "  -v, --version        Display version and exit\n"
288 |         "\n"
289 |         "Markdown dialect options:\n"
290 |         "(note these are equivalent to some combinations of the flags below)\n"
291 |         "      --commonmark     CommonMark (this is default)\n"
292 |         "      --github         Github Flavored Markdown\n"
293 |         "\n"
294 |         "Markdown extension options:\n"
295 |         "      --fcollapse-whitespace\n"
296 |         "                       Collapse non-trivial whitespace\n"
297 |         "      --flatex-math    Enable LaTeX style mathematics spans\n"
298 |         "      --fpermissive-atx-headers\n"
299 |         "                       Allow ATX headers without delimiting space\n"
300 |         "      --fpermissive-url-autolinks\n"
301 |         "                       Allow URL autolinks without '<', '>'\n"
302 |         "      --fpermissive-www-autolinks\n"
303 |         "                       Allow WWW autolinks without any scheme (e.g. 'www.example.com')\n"
304 |         "      --fpermissive-email-autolinks  \n"
305 |         "                       Allow e-mail autolinks without '<', '>' and 'mailto:'\n"
306 |         "      --fpermissive-autolinks\n"
307 |         "                       Same as --fpermissive-url-autolinks --fpermissive-www-autolinks\n"
308 |         "                       --fpermissive-email-autolinks\n"
309 |         "      --fhard-soft-breaks\n"
310 |         "                       Force all soft breaks to act as hard breaks\n"
311 |         "      --fstrikethrough Enable strike-through spans\n"
312 |         "      --ftables        Enable tables\n"
313 |         "      --ftasklists     Enable task lists\n"
314 |         "      --funderline     Enable underline spans\n"
315 |         "      --fwiki-links    Enable wiki links\n"
316 |         "\n"
317 |         "Markdown suppression options:\n"
318 |         "      --fno-html-blocks\n"
319 |         "                       Disable raw HTML blocks\n"
320 |         "      --fno-html-spans\n"
321 |         "                       Disable raw HTML spans\n"
322 |         "      --fno-html       Same as --fno-html-blocks --fno-html-spans\n"
323 |         "      --fno-indented-code\n"
324 |         "                       Disable indented code blocks\n"
325 |         "\n"
326 |         "HTML generator options:\n"
327 |         "      --fverbatim-entities\n"
328 |         "                       Do not translate entities\n"
329 |         "      --html-title=TITLE Sets the title of the document\n"
330 |         "      --html-css=URL   In full HTML or XHTML mode add a css link\n"
331 |         "\n"
332 |     );
333 | }
334 | 
335 | static void
336 | version(void)
337 | {
338 |     printf("%d.%d.%d\n", MD_VERSION_MAJOR, MD_VERSION_MINOR, MD_VERSION_RELEASE);
339 | }
340 | 
341 | static const char* input_path = NULL;
342 | static const char* output_path = NULL;
343 | 
344 | static int
345 | cmdline_callback(int opt, char const* value, void* data)
346 | {
347 |     (void) data;   /* unused parameter */
348 | 
349 |     switch(opt) {
350 |         case 0:
351 |             if(input_path) {
352 |                 fprintf(stderr, "Too many arguments. Only one input file can be specified.\n");
353 |                 fprintf(stderr, "Use --help for more info.\n");
354 |                 exit(1);
355 |             }
356 |             input_path = value;
357 |             break;
358 | 
359 |         case 'o':   output_path = value; break;
360 |         case 'f':   want_fullhtml = 1; break;
361 |         case 'x':   want_xhtml = 1; renderer_flags |= MD_HTML_FLAG_XHTML; break;
362 |         case 's':   want_stat = 1; break;
363 |         case 'r':   want_replay_fuzz = 1; break;
364 |         case 'h':   usage(); exit(0); break;
365 |         case 'v':   version(); exit(0); break;
366 | 
367 |         case '1':   html_title = value; break;
368 |         case '2':   css_path = value; break;
369 | 
370 |         case 'c':   parser_flags |= MD_DIALECT_COMMONMARK; break;
371 |         case 'g':   parser_flags |= MD_DIALECT_GITHUB; break;
372 | 
373 |         case 'E':   renderer_flags |= MD_HTML_FLAG_VERBATIM_ENTITIES; break;
374 |         case 'A':   parser_flags |= MD_FLAG_PERMISSIVEATXHEADERS; break;
375 |         case 'I':   parser_flags |= MD_FLAG_NOINDENTEDCODEBLOCKS; break;
376 |         case 'F':   parser_flags |= MD_FLAG_NOHTMLBLOCKS; break;
377 |         case 'G':   parser_flags |= MD_FLAG_NOHTMLSPANS; break;
378 |         case 'H':   parser_flags |= MD_FLAG_NOHTML; break;
379 |         case 'W':   parser_flags |= MD_FLAG_COLLAPSEWHITESPACE; break;
380 |         case 'U':   parser_flags |= MD_FLAG_PERMISSIVEURLAUTOLINKS; break;
381 |         case '.':   parser_flags |= MD_FLAG_PERMISSIVEWWWAUTOLINKS; break;
382 |         case '@':   parser_flags |= MD_FLAG_PERMISSIVEEMAILAUTOLINKS; break;
383 |         case 'V':   parser_flags |= MD_FLAG_PERMISSIVEAUTOLINKS; break;
384 |         case 'T':   parser_flags |= MD_FLAG_TABLES; break;
385 |         case 'S':   parser_flags |= MD_FLAG_STRIKETHROUGH; break;
386 |         case 'L':   parser_flags |= MD_FLAG_LATEXMATHSPANS; break;
387 |         case 'K':   parser_flags |= MD_FLAG_WIKILINKS; break;
388 |         case 'X':   parser_flags |= MD_FLAG_TASKLISTS; break;
389 |         case '_':   parser_flags |= MD_FLAG_UNDERLINE; break;
390 |         case 'B':   parser_flags |= MD_FLAG_HARD_SOFT_BREAKS; break;
391 | 
392 |         default:
393 |             fprintf(stderr, "Illegal option: %s\n", value);
394 |             fprintf(stderr, "Use --help for more info.\n");
395 |             exit(1);
396 |             break;
397 |     }
398 | 
399 |     return 0;
400 | }
401 | 
402 | int
403 | main(int argc, char** argv)
404 | {
405 |     FILE* in = stdin;
406 |     FILE* out = stdout;
407 |     int ret = 0;
408 | 
409 |     if(cmdline_read(cmdline_options, argc, argv, cmdline_callback, NULL) != 0) {
410 |         usage();
411 |         exit(1);
412 |     }
413 | 
414 |     if(input_path != NULL && strcmp(input_path, "-") != 0) {
415 |         in = fopen(input_path, "rb");
416 |         if(in == NULL) {
417 |             fprintf(stderr, "Cannot open %s.\n", input_path);
418 |             exit(1);
419 |         }
420 |     }
421 |     if(output_path != NULL && strcmp(output_path, "-") != 0) {
422 |         out = fopen(output_path, "wt");
423 |         if(out == NULL) {
424 |             fprintf(stderr, "Cannot open %s.\n", output_path);
425 |             exit(1);
426 |         }
427 |     }
428 | 
429 |     ret = process_file((input_path != NULL) ? input_path : "<stdin>", in, out);
430 |     if(in != stdin)
431 |         fclose(in);
432 |     if(out != stdout)
433 |         fclose(out);
434 | 
435 |     return ret;
436 | }
437 | 


--------------------------------------------------------------------------------
/scripts/build_entity_map.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import os
 4 | import sys
 5 | import json
 6 | import urllib.request
 7 | 
 8 | 
 9 | url_str = "https://html.spec.whatwg.org/entities.json"
10 | 
11 | with urllib.request.urlopen(url_str) as url:
12 |     entities = json.load(url)
13 | 
14 | records = []
15 | 
16 | for name in entities:
17 |     if name[-1] != ';':
18 |         continue
19 | 
20 |     codepoints = entities[name]["codepoints"]
21 | 
22 |     if len(codepoints) > 2:
23 |         print('Entity {} needs {} codepints; may need to update the .c code '
24 |                 ' accordingly.'.format(name, len(codepoints)), file=sys.stderr)
25 |         sys.exit(1)
26 | 
27 |     while len(codepoints) < 2:
28 |         codepoints.append(0)
29 | 
30 |     codepoints_str = map(str, codepoints)
31 |     records.append("    { \"" + name + "\", { " + ", ".join(codepoints_str) + " } }")
32 | 
33 | records.sort()
34 | 
35 | sys.stdout.write("static const ENTITY ENTITY_MAP[] = {\n")
36 | sys.stdout.write(",\n".join(records))
37 | sys.stdout.write("\n};\n\n")
38 | 


--------------------------------------------------------------------------------
/scripts/build_folding_map.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | import os
  4 | import sys
  5 | import textwrap
  6 | 
  7 | 
  8 | self_path = os.path.dirname(os.path.realpath(__file__));
  9 | f = open(self_path + "/unicode/CaseFolding.txt", "r")
 10 | 
 11 | status_list = [ "C", "F" ]
 12 | 
 13 | folding_list = [ dict(), dict(), dict() ]
 14 | 
 15 | # Filter the foldings for "full" folding.
 16 | for line in f:
 17 |     comment_off = line.find("#")
 18 |     if comment_off >= 0:
 19 |         line = line[:comment_off]
 20 |     line = line.strip()
 21 |     if not line:
 22 |         continue
 23 | 
 24 |     raw_codepoint, status, raw_mapping, ignored_tail = line.split(";", 3)
 25 |     if not status.strip() in status_list:
 26 |         continue
 27 |     codepoint = int(raw_codepoint.strip(), 16)
 28 |     mapping = [int(it, 16) for it in raw_mapping.strip().split(" ")]
 29 |     mapping_len = len(mapping)
 30 | 
 31 |     if mapping_len in range(1, 4):
 32 |         folding_list[mapping_len-1][codepoint] = mapping
 33 |     else:
 34 |         assert(False)
 35 | f.close()
 36 | 
 37 | 
 38 | # If we assume that (index0 ... index-1) makes a range (as defined below),
 39 | # check that the newly provided index is compatible with the range too; i.e.
 40 | # verify that the range can be extended without breaking its properties.
 41 | #
 42 | # Currently, we can handle ranges which:
 43 | #
 44 | # (1) either form consecutive sequence of codepoints and which map that range
 45 | #     to other consecutive range of codepoints (of the same length);
 46 | #
 47 | # (2) or a consecutive sequence of codepoints with step 2 where each codepoint
 48 | #     CP is mapped to the codepoint CP+1
 49 | #     (e.g. 0x1234 -> 0x1235; 0x1236 -> 0x1237; 0x1238 -> 0x1239; ...).
 50 | #
 51 | # Note: When the codepoints in the range are mapped to multiple codepoints,
 52 | # only the 1st mapped codepoint is considered. All the other ones have to be
 53 | # shared by all the mappings covered by the range.
 54 | def is_range_compatible(folding, codepoint_list, index0, index):
 55 |     N = index - index0
 56 |     codepoint0 = codepoint_list[index0]
 57 |     codepoint1 = codepoint_list[index0+1]
 58 |     codepointN = codepoint_list[index]
 59 |     mapping0 = folding[codepoint0]
 60 |     mapping1 = folding[codepoint1]
 61 |     mappingN = folding[codepointN]
 62 | 
 63 |     # Check the range type (1):
 64 |     if codepoint1 - codepoint0 == 1 and codepointN - codepoint0 == N                \
 65 |             and mapping1[0] - mapping0[0] == 1 and mapping1[1:] == mapping0[1:]     \
 66 |             and mappingN[0] - mapping0[0] == N and mappingN[1:] == mapping0[1:]:
 67 |         return True
 68 | 
 69 |     # Check the range type (2):
 70 |     if codepoint1 - codepoint0 == 2 and codepointN - codepoint0 == 2 * N            \
 71 |             and mapping0[0] - codepoint0 == 1                                       \
 72 |             and mapping1[0] - codepoint1 == 1 and mapping1[1:] == mapping0[1:]      \
 73 |             and mappingN[0] - codepointN == 1 and mappingN[1:] == mapping0[1:]:
 74 |         return True
 75 | 
 76 |     return False
 77 | 
 78 | 
 79 | def mapping_str(list, mapping):
 80 |     return ",".join("0x{:04x}".format(x) for x in mapping)
 81 | 
 82 | for mapping_len in range(1, 4):
 83 |     folding = folding_list[mapping_len-1]
 84 |     codepoint_list = list(folding)
 85 | 
 86 |     index0 = 0
 87 |     count = len(folding)
 88 | 
 89 |     records = list()
 90 |     data_records = list()
 91 | 
 92 |     while index0 < count:
 93 |         index1 = index0 + 1
 94 |         while index1 < count and is_range_compatible(folding, codepoint_list, index0, index1):
 95 |             index1 += 1
 96 | 
 97 |         if index1 - index0 > 2:
 98 |             # Range of codepoints
 99 |             records.append("R(0x{:04x},0x{:04x})".format(codepoint_list[index0], codepoint_list[index1-1]))
100 |             data_records.append(mapping_str(data_records, folding[codepoint_list[index0]]))
101 |             data_records.append(mapping_str(data_records, folding[codepoint_list[index1-1]]))
102 |             index0 = index1
103 |         else:
104 |             # Single codepoint
105 |             records.append("S(0x{:04x})".format(codepoint_list[index0]))
106 |             data_records.append(mapping_str(data_records, folding[codepoint_list[index0]]))
107 |             index0 += 1
108 | 
109 |     sys.stdout.write("static const unsigned FOLD_MAP_{}[] = {{\n".format(mapping_len))
110 |     sys.stdout.write("\n".join(textwrap.wrap(", ".join(records), 110,
111 |                         initial_indent = "    ", subsequent_indent="    ")))
112 |     sys.stdout.write("\n};\n")
113 | 
114 |     sys.stdout.write("static const unsigned FOLD_MAP_{}_DATA[] = {{\n".format(mapping_len))
115 |     sys.stdout.write("\n".join(textwrap.wrap(", ".join(data_records), 110,
116 |                         initial_indent = "    ", subsequent_indent="    ")))
117 |     sys.stdout.write("\n};\n")
118 | 
119 | 
120 | 
121 | 


--------------------------------------------------------------------------------
/scripts/build_punct_map.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import os
 4 | import sys
 5 | import textwrap
 6 | 
 7 | 
 8 | self_path = os.path.dirname(os.path.realpath(__file__));
 9 | f = open(self_path + "/unicode/DerivedGeneralCategory.txt", "r")
10 | 
11 | codepoint_list = []
12 | 
13 | # Filter codepoints falling in the right category:
14 | for line in f:
15 |     comment_off = line.find("#")
16 |     if comment_off >= 0:
17 |         line = line[:comment_off]
18 |     line = line.strip()
19 |     if not line:
20 |         continue
21 | 
22 |     char_range, category = line.split(";")
23 |     char_range = char_range.strip()
24 |     category = category.strip()
25 | 
26 |     if category[0] != 'P' and category[0] != 'S':
27 |         continue
28 | 
29 |     delim_off = char_range.find("..")
30 |     if delim_off >= 0:
31 |         codepoint0 = int(char_range[:delim_off], 16)
32 |         codepoint1 = int(char_range[delim_off+2:], 16)
33 |         for codepoint in range(codepoint0, codepoint1 + 1):
34 |             codepoint_list.append(codepoint)
35 |     else:
36 |         codepoint = int(char_range, 16)
37 |         codepoint_list.append(codepoint)
38 | f.close()
39 | 
40 | 
41 | codepoint_list.sort()
42 | 
43 | 
44 | index0 = 0
45 | count = len(codepoint_list)
46 | 
47 | records = list()
48 | while index0 < count:
49 |     index1 = index0 + 1
50 |     while index1 < count and codepoint_list[index1] == codepoint_list[index1-1] + 1:
51 |         index1 += 1
52 | 
53 |     if index1 - index0 > 1:
54 |         # Range of codepoints
55 |         records.append("R(0x{:04x},0x{:04x})".format(codepoint_list[index0], codepoint_list[index1-1]))
56 |     else:
57 |         # Single codepoint
58 |         records.append("S(0x{:04x})".format(codepoint_list[index0]))
59 | 
60 |     index0 = index1
61 | 
62 | sys.stdout.write("static const unsigned PUNCT_MAP[] = {\n")
63 | sys.stdout.write("\n".join(textwrap.wrap(", ".join(records), 110,
64 |                     initial_indent = "    ", subsequent_indent="    ")))
65 | sys.stdout.write("\n};\n\n")
66 | 


--------------------------------------------------------------------------------
/scripts/build_whitespace_map.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import os
 4 | import sys
 5 | import textwrap
 6 | 
 7 | 
 8 | self_path = os.path.dirname(os.path.realpath(__file__));
 9 | f = open(self_path + "/unicode/DerivedGeneralCategory.txt", "r")
10 | 
11 | codepoint_list = []
12 | category_list = [ "Zs" ]
13 | 
14 | # Filter codepoints falling in the right category:
15 | for line in f:
16 |     comment_off = line.find("#")
17 |     if comment_off >= 0:
18 |         line = line[:comment_off]
19 |     line = line.strip()
20 |     if not line:
21 |         continue
22 | 
23 |     char_range, category = line.split(";")
24 |     char_range = char_range.strip()
25 |     category = category.strip()
26 | 
27 |     if not category in category_list:
28 |         continue
29 | 
30 |     delim_off = char_range.find("..")
31 |     if delim_off >= 0:
32 |         codepoint0 = int(char_range[:delim_off], 16)
33 |         codepoint1 = int(char_range[delim_off+2:], 16)
34 |         for codepoint in range(codepoint0, codepoint1 + 1):
35 |             codepoint_list.append(codepoint)
36 |     else:
37 |         codepoint = int(char_range, 16)
38 |         codepoint_list.append(codepoint)
39 | f.close()
40 | 
41 | 
42 | codepoint_list.sort()
43 | 
44 | 
45 | index0 = 0
46 | count = len(codepoint_list)
47 | 
48 | records = list()
49 | while index0 < count:
50 |     index1 = index0 + 1
51 |     while index1 < count and codepoint_list[index1] == codepoint_list[index1-1] + 1:
52 |         index1 += 1
53 | 
54 |     if index1 - index0 > 1:
55 |         # Range of codepoints
56 |         records.append("R(0x{:04x},0x{:04x})".format(codepoint_list[index0], codepoint_list[index1-1]))
57 |     else:
58 |         # Single codepoint
59 |         records.append("S(0x{:04x})".format(codepoint_list[index0]))
60 | 
61 |     index0 = index1
62 | 
63 | sys.stdout.write("static const unsigned WHITESPACE_MAP[] = {\n")
64 | sys.stdout.write("\n".join(textwrap.wrap(", ".join(records), 110,
65 |                     initial_indent = "    ", subsequent_indent="    ")))
66 | sys.stdout.write("\n};\n\n")
67 | 


--------------------------------------------------------------------------------
/scripts/coverity.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | #
 3 | # This scripts attempts to build the project via cov-build utility, and prepare
 4 | # a package for uploading to the coverity scan service.
 5 | #
 6 | # (See http://scan.coverity.com for more info.)
 7 | 
 8 | set -e
 9 | 
10 | # Check presence of coverity static analyzer.
11 | if ! which cov-build; then
12 |     echo "Utility cov-build not found in PATH."
13 |     exit 1
14 | fi
15 | 
16 | # Choose a build system (ninja or GNU make).
17 | if which ninja; then
18 |     BUILD_TOOL=ninja
19 |     GENERATOR=Ninja
20 | elif which make; then
21 |     BUILD_TOOL=make
22 |     GENERATOR="MSYS Makefiles"
23 | else
24 |     echo "No suitable build system found."
25 |     exit 1
26 | fi
27 | 
28 | # Choose a zip tool.
29 | if which 7za; then
30 |     MKZIP="7za a -r -mx9"
31 | elif which 7z; then
32 |     MKZIP="7z a -r -mx9"
33 | elif which zip; then
34 |     MKZIP="zip -r"
35 | else
36 |     echo "No suitable zip utility found"
37 |     exit 1
38 | fi
39 | 
40 | # Change dir to project root.
41 | cd `dirname "$0"`/..
42 | 
43 | CWD=`pwd`
44 | ROOT_DIR="$CWD"
45 | BUILD_DIR="$CWD/coverity"
46 | OUTPUT="$CWD/cov-int.zip"
47 | 
48 | # Sanity checks.
49 | if [ ! -x "$ROOT_DIR/scripts/coverity.sh" ]; then
50 |     echo "There is some path mismatch."
51 |     exit 1
52 | fi
53 | if [ -e "$BUILD_DIR" ]; then
54 |     echo "Path $BUILD_DIR already exists. Delete it and retry."
55 |     exit 1
56 | fi
57 | if [ -e "$OUTPUT" ]; then
58 |     echo "Path $OUTPUT already exists. Delete it and retry."
59 |     exit 1
60 | fi
61 | 
62 | # Build the project with the Coverity analyzes enabled.
63 | mkdir -p "$BUILD_DIR"
64 | cd "$BUILD_DIR"
65 | cmake -G "$GENERATOR" "$ROOT_DIR"
66 | cov-build --dir cov-int "$BUILD_TOOL"
67 | $MKZIP "$OUTPUT" "cov-int"
68 | cd "$ROOT_DIR"
69 | rm -rf "$BUILD_DIR"
70 | 
71 | 


--------------------------------------------------------------------------------
/scripts/run-tests.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import glob
 4 | import os
 5 | import subprocess
 6 | import sys
 7 | 
 8 | 
 9 | argv0_dir = os.path.dirname(sys.argv[0])
10 | project_dir = os.path.abspath(os.path.join(argv0_dir, ".."))
11 | test_dir = os.path.join(project_dir, "test")
12 | program = os.path.abspath(os.path.join("md2html", "md2html"))
13 | 
14 | if __name__ == "__main__":
15 |     err_count = 0
16 | 
17 |     os.chdir(test_dir)
18 | 
19 |     for testsuite in glob.glob('*.txt'):
20 |         print("Testing {}".format(testsuite))
21 |         sys.stdout.flush()
22 |         sys.stderr.flush()
23 |         args = [
24 |                 sys.executable,
25 |                 "run-testsuite.py",
26 |                 "-s", testsuite,
27 |                 "-p", str(program)
28 |         ]
29 |         p = subprocess.run(args)
30 |         if p.returncode != 0:
31 |             err_count += 1
32 |         print()
33 | 
34 |     print("Testing pathological inputs:")
35 |     sys.stdout.flush()
36 |     sys.stderr.flush()
37 |     args = [
38 |             sys.executable,
39 |             "pathological-tests.py",
40 |             "-p", str(program)
41 |     ]
42 |     subprocess.run(args)
43 |     if p.returncode != 0:
44 |         err_count += 1
45 | 
46 |     sys.exit(err_count)
47 | 


--------------------------------------------------------------------------------
/src/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS 1)
 3 | set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG")
 4 | 
 5 | 
 6 | # Build rules for MD4C parser library
 7 | 
 8 | configure_file(md4c.pc.in md4c.pc @ONLY)
 9 | add_library(md4c md4c.c md4c.h)
10 | set_target_properties(md4c PROPERTIES
11 |     COMPILE_FLAGS "-DMD4C_USE_UTF8"
12 |     VERSION ${MD_VERSION}
13 |     SOVERSION ${MD_VERSION_MAJOR}
14 |     PUBLIC_HEADER md4c.h
15 | )
16 | 
17 | # Build rules for HTML renderer library
18 | 
19 | configure_file(md4c-html.pc.in md4c-html.pc @ONLY)
20 | add_library(md4c-html md4c-html.c md4c-html.h entity.c entity.h)
21 | set_target_properties(md4c-html PROPERTIES
22 |     VERSION ${MD_VERSION}
23 |     SOVERSION ${MD_VERSION_MAJOR}
24 |     PUBLIC_HEADER md4c-html.h
25 | )
26 | target_link_libraries(md4c-html md4c)
27 | 
28 | 
29 | # Install rules
30 | 
31 | install(
32 |     TARGETS md4c
33 |     EXPORT md4cConfig
34 |     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
35 |     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
36 |     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
37 |     PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
38 |     INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
39 | )
40 | install(FILES ${CMAKE_BINARY_DIR}/src/md4c.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
41 | 
42 | install(
43 |     TARGETS md4c-html
44 |     EXPORT md4cConfig
45 |     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
46 |     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
47 |     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
48 |     PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
49 | )
50 | install(FILES ${CMAKE_BINARY_DIR}/src/md4c-html.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
51 | 
52 | install(EXPORT md4cConfig DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/md4c/ NAMESPACE md4c::)
53 | 
54 | 


--------------------------------------------------------------------------------
/src/entity.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * MD4C: Markdown parser for C
 3 |  * (http://github.com/mity/md4c)
 4 |  *
 5 |  * Copyright (c) 2016-2024 Martin Mitáš
 6 |  *
 7 |  * Permission is hereby granted, free of charge, to any person obtaining a
 8 |  * copy of this software and associated documentation files (the "Software"),
 9 |  * to deal in the Software without restriction, including without limitation
10 |  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 |  * and/or sell copies of the Software, and to permit persons to whom the
12 |  * Software is furnished to do so, subject to the following conditions:
13 |  *
14 |  * The above copyright notice and this permission notice shall be included in
15 |  * all copies or substantial portions of the Software.
16 |  *
17 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 |  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 |  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
23 |  * IN THE SOFTWARE.
24 |  */
25 | 
26 | #ifndef MD4C_ENTITY_H
27 | #define MD4C_ENTITY_H
28 | 
29 | #include <stdlib.h>
30 | 
31 | 
32 | /* Most entities are formed by single Unicode codepoint, few by two codepoints.
33 |  * Single-codepoint entities have codepoints[1] set to zero. */
34 | typedef struct ENTITY_tag ENTITY;
35 | struct ENTITY_tag {
36 |     const char* name;
37 |     unsigned codepoints[2];
38 | };
39 | 
40 | const ENTITY* entity_lookup(const char* name, size_t name_size);
41 | 
42 | 
43 | #endif  /* MD4C_ENTITY_H */
44 | 


--------------------------------------------------------------------------------
/src/md4c-html.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * MD4C: Markdown parser for C
  3 |  * (http://github.com/mity/md4c)
  4 |  *
  5 |  * Copyright (c) 2016-2024 Martin Mitáš
  6 |  *
  7 |  * Permission is hereby granted, free of charge, to any person obtaining a
  8 |  * copy of this software and associated documentation files (the "Software"),
  9 |  * to deal in the Software without restriction, including without limitation
 10 |  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 11 |  * and/or sell copies of the Software, and to permit persons to whom the
 12 |  * Software is furnished to do so, subject to the following conditions:
 13 |  *
 14 |  * The above copyright notice and this permission notice shall be included in
 15 |  * all copies or substantial portions of the Software.
 16 |  *
 17 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 18 |  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 19 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 20 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 21 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 22 |  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 23 |  * IN THE SOFTWARE.
 24 |  */
 25 | 
 26 | #include <stdio.h>
 27 | #include <string.h>
 28 | 
 29 | #include "md4c-html.h"
 30 | #include "entity.h"
 31 | 
 32 | 
 33 | #if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199409L
 34 |     /* C89/90 or old compilers in general may not understand "inline". */
 35 |     #if defined __GNUC__
 36 |         #define inline __inline__
 37 |     #elif defined _MSC_VER
 38 |         #define inline __inline
 39 |     #else
 40 |         #define inline
 41 |     #endif
 42 | #endif
 43 | 
 44 | #ifdef _WIN32
 45 |     #define snprintf _snprintf
 46 | #endif
 47 | 
 48 | 
 49 | 
 50 | typedef struct MD_HTML_tag MD_HTML;
 51 | struct MD_HTML_tag {
 52 |     void (*process_output)(const MD_CHAR*, MD_SIZE, void*);
 53 |     void* userdata;
 54 |     unsigned flags;
 55 |     int image_nesting_level;
 56 |     char escape_map[256];
 57 | };
 58 | 
 59 | #define NEED_HTML_ESC_FLAG   0x1
 60 | #define NEED_URL_ESC_FLAG    0x2
 61 | 
 62 | 
 63 | /*****************************************
 64 |  ***  HTML rendering helper functions  ***
 65 |  *****************************************/
 66 | 
 67 | #define ISDIGIT(ch)     ('0' <= (ch) && (ch) <= '9')
 68 | #define ISLOWER(ch)     ('a' <= (ch) && (ch) <= 'z')
 69 | #define ISUPPER(ch)     ('A' <= (ch) && (ch) <= 'Z')
 70 | #define ISALNUM(ch)     (ISLOWER(ch) || ISUPPER(ch) || ISDIGIT(ch))
 71 | 
 72 | 
 73 | static inline void
 74 | render_verbatim(MD_HTML* r, const MD_CHAR* text, MD_SIZE size)
 75 | {
 76 |     r->process_output(text, size, r->userdata);
 77 | }
 78 | 
 79 | /* Keep this as a macro. Most compiler should then be smart enough to replace
 80 |  * the strlen() call with a compile-time constant if the string is a C literal. */
 81 | #define RENDER_VERBATIM(r, verbatim)                                    \
 82 |         render_verbatim((r), (verbatim), (MD_SIZE) (strlen(verbatim)))
 83 | 
 84 | 
 85 | static void
 86 | render_html_escaped(MD_HTML* r, const MD_CHAR* data, MD_SIZE size)
 87 | {
 88 |     MD_OFFSET beg = 0;
 89 |     MD_OFFSET off = 0;
 90 | 
 91 |     /* Some characters need to be escaped in normal HTML text. */
 92 |     #define NEED_HTML_ESC(ch)   (r->escape_map[(unsigned char)(ch)] & NEED_HTML_ESC_FLAG)
 93 | 
 94 |     while(1) {
 95 |         /* Optimization: Use some loop unrolling. */
 96 |         while(off + 3 < size  &&  !NEED_HTML_ESC(data[off+0])  &&  !NEED_HTML_ESC(data[off+1])
 97 |                               &&  !NEED_HTML_ESC(data[off+2])  &&  !NEED_HTML_ESC(data[off+3]))
 98 |             off += 4;
 99 |         while(off < size  &&  !NEED_HTML_ESC(data[off]))
100 |             off++;
101 | 
102 |         if(off > beg)
103 |             render_verbatim(r, data + beg, off - beg);
104 | 
105 |         if(off < size) {
106 |             switch(data[off]) {
107 |                 case '&':   RENDER_VERBATIM(r, "&amp;"); break;
108 |                 case '<':   RENDER_VERBATIM(r, "&lt;"); break;
109 |                 case '>':   RENDER_VERBATIM(r, "&gt;"); break;
110 |                 case '"':   RENDER_VERBATIM(r, "&quot;"); break;
111 |             }
112 |             off++;
113 |         } else {
114 |             break;
115 |         }
116 |         beg = off;
117 |     }
118 | }
119 | 
120 | static void
121 | render_url_escaped(MD_HTML* r, const MD_CHAR* data, MD_SIZE size)
122 | {
123 |     static const MD_CHAR hex_chars[] = "0123456789ABCDEF";
124 |     MD_OFFSET beg = 0;
125 |     MD_OFFSET off = 0;
126 | 
127 |     /* Some characters need to be escaped in URL attributes. */
128 |     #define NEED_URL_ESC(ch)    (r->escape_map[(unsigned char)(ch)] & NEED_URL_ESC_FLAG)
129 | 
130 |     while(1) {
131 |         while(off < size  &&  !NEED_URL_ESC(data[off]))
132 |             off++;
133 |         if(off > beg)
134 |             render_verbatim(r, data + beg, off - beg);
135 | 
136 |         if(off < size) {
137 |             char hex[3];
138 | 
139 |             switch(data[off]) {
140 |                 case '&':   RENDER_VERBATIM(r, "&amp;"); break;
141 |                 default:
142 |                     hex[0] = '%';
143 |                     hex[1] = hex_chars[((unsigned)data[off] >> 4) & 0xf];
144 |                     hex[2] = hex_chars[((unsigned)data[off] >> 0) & 0xf];
145 |                     render_verbatim(r, hex, 3);
146 |                     break;
147 |             }
148 |             off++;
149 |         } else {
150 |             break;
151 |         }
152 | 
153 |         beg = off;
154 |     }
155 | }
156 | 
157 | static unsigned
158 | hex_val(char ch)
159 | {
160 |     if('0' <= ch && ch <= '9')
161 |         return ch - '0';
162 |     if('A' <= ch && ch <= 'Z')
163 |         return ch - 'A' + 10;
164 |     else
165 |         return ch - 'a' + 10;
166 | }
167 | 
168 | static void
169 | render_utf8_codepoint(MD_HTML* r, unsigned codepoint,
170 |                       void (*fn_append)(MD_HTML*, const MD_CHAR*, MD_SIZE))
171 | {
172 |     static const MD_CHAR utf8_replacement_char[] = { (char)0xef, (char)0xbf, (char)0xbd };
173 | 
174 |     unsigned char utf8[4];
175 |     size_t n;
176 | 
177 |     if(codepoint <= 0x7f) {
178 |         n = 1;
179 |         utf8[0] = codepoint;
180 |     } else if(codepoint <= 0x7ff) {
181 |         n = 2;
182 |         utf8[0] = 0xc0 | ((codepoint >>  6) & 0x1f);
183 |         utf8[1] = 0x80 + ((codepoint >>  0) & 0x3f);
184 |     } else if(codepoint <= 0xffff) {
185 |         n = 3;
186 |         utf8[0] = 0xe0 | ((codepoint >> 12) & 0xf);
187 |         utf8[1] = 0x80 + ((codepoint >>  6) & 0x3f);
188 |         utf8[2] = 0x80 + ((codepoint >>  0) & 0x3f);
189 |     } else {
190 |         n = 4;
191 |         utf8[0] = 0xf0 | ((codepoint >> 18) & 0x7);
192 |         utf8[1] = 0x80 + ((codepoint >> 12) & 0x3f);
193 |         utf8[2] = 0x80 + ((codepoint >>  6) & 0x3f);
194 |         utf8[3] = 0x80 + ((codepoint >>  0) & 0x3f);
195 |     }
196 | 
197 |     if(0 < codepoint  &&  codepoint <= 0x10ffff)
198 |         fn_append(r, (char*)utf8, (MD_SIZE)n);
199 |     else
200 |         fn_append(r, utf8_replacement_char, 3);
201 | }
202 | 
203 | /* Translate entity to its UTF-8 equivalent, or output the verbatim one
204 |  * if such entity is unknown (or if the translation is disabled). */
205 | static void
206 | render_entity(MD_HTML* r, const MD_CHAR* text, MD_SIZE size,
207 |               void (*fn_append)(MD_HTML*, const MD_CHAR*, MD_SIZE))
208 | {
209 |     if(r->flags & MD_HTML_FLAG_VERBATIM_ENTITIES) {
210 |         render_verbatim(r, text, size);
211 |         return;
212 |     }
213 | 
214 |     /* We assume UTF-8 output is what is desired. */
215 |     if(size > 3 && text[1] == '#') {
216 |         unsigned codepoint = 0;
217 | 
218 |         if(text[2] == 'x' || text[2] == 'X') {
219 |             /* Hexadecimal entity (e.g. "&#x1234abcd;")). */
220 |             MD_SIZE i;
221 |             for(i = 3; i < size-1; i++)
222 |                 codepoint = 16 * codepoint + hex_val(text[i]);
223 |         } else {
224 |             /* Decimal entity (e.g. "&1234;") */
225 |             MD_SIZE i;
226 |             for(i = 2; i < size-1; i++)
227 |                 codepoint = 10 * codepoint + (text[i] - '0');
228 |         }
229 | 
230 |         render_utf8_codepoint(r, codepoint, fn_append);
231 |         return;
232 |     } else {
233 |         /* Named entity (e.g. "&nbsp;"). */
234 |         const ENTITY* ent;
235 | 
236 |         ent = entity_lookup(text, size);
237 |         if(ent != NULL) {
238 |             render_utf8_codepoint(r, ent->codepoints[0], fn_append);
239 |             if(ent->codepoints[1])
240 |                 render_utf8_codepoint(r, ent->codepoints[1], fn_append);
241 |             return;
242 |         }
243 |     }
244 | 
245 |     fn_append(r, text, size);
246 | }
247 | 
248 | static void
249 | render_attribute(MD_HTML* r, const MD_ATTRIBUTE* attr,
250 |                  void (*fn_append)(MD_HTML*, const MD_CHAR*, MD_SIZE))
251 | {
252 |     int i;
253 | 
254 |     for(i = 0; attr->substr_offsets[i] < attr->size; i++) {
255 |         MD_TEXTTYPE type = attr->substr_types[i];
256 |         MD_OFFSET off = attr->substr_offsets[i];
257 |         MD_SIZE size = attr->substr_offsets[i+1] - off;
258 |         const MD_CHAR* text = attr->text + off;
259 | 
260 |         switch(type) {
261 |             case MD_TEXT_NULLCHAR:  render_utf8_codepoint(r, 0x0000, render_verbatim); break;
262 |             case MD_TEXT_ENTITY:    render_entity(r, text, size, fn_append); break;
263 |             default:                fn_append(r, text, size); break;
264 |         }
265 |     }
266 | }
267 | 
268 | 
269 | static void
270 | render_open_ol_block(MD_HTML* r, const MD_BLOCK_OL_DETAIL* det)
271 | {
272 |     char buf[64];
273 | 
274 |     if(det->start == 1) {
275 |         RENDER_VERBATIM(r, "<ol>\n");
276 |         return;
277 |     }
278 | 
279 |     snprintf(buf, sizeof(buf), "<ol start=\"%u\">\n", det->start);
280 |     RENDER_VERBATIM(r, buf);
281 | }
282 | 
283 | static void
284 | render_open_li_block(MD_HTML* r, const MD_BLOCK_LI_DETAIL* det)
285 | {
286 |     if(det->is_task) {
287 |         RENDER_VERBATIM(r, "<li class=\"task-list-item\">"
288 |                           "<input type=\"checkbox\" class=\"task-list-item-checkbox\" disabled");
289 |         if(det->task_mark == 'x' || det->task_mark == 'X')
290 |             RENDER_VERBATIM(r, " checked");
291 |         RENDER_VERBATIM(r, ">");
292 |     } else {
293 |         RENDER_VERBATIM(r, "<li>");
294 |     }
295 | }
296 | 
297 | static void
298 | render_open_code_block(MD_HTML* r, const MD_BLOCK_CODE_DETAIL* det)
299 | {
300 |     RENDER_VERBATIM(r, "<pre><code");
301 | 
302 |     /* If known, output the HTML 5 attribute class="language-LANGNAME". */
303 |     if(det->lang.text != NULL) {
304 |         RENDER_VERBATIM(r, " class=\"language-");
305 |         render_attribute(r, &det->lang, render_html_escaped);
306 |         RENDER_VERBATIM(r, "\"");
307 |     }
308 | 
309 |     RENDER_VERBATIM(r, ">");
310 | }
311 | 
312 | static void
313 | render_open_td_block(MD_HTML* r, const MD_CHAR* cell_type, const MD_BLOCK_TD_DETAIL* det)
314 | {
315 |     RENDER_VERBATIM(r, "<");
316 |     RENDER_VERBATIM(r, cell_type);
317 | 
318 |     switch(det->align) {
319 |         case MD_ALIGN_LEFT:     RENDER_VERBATIM(r, " align=\"left\">"); break;
320 |         case MD_ALIGN_CENTER:   RENDER_VERBATIM(r, " align=\"center\">"); break;
321 |         case MD_ALIGN_RIGHT:    RENDER_VERBATIM(r, " align=\"right\">"); break;
322 |         default:                RENDER_VERBATIM(r, ">"); break;
323 |     }
324 | }
325 | 
326 | static void
327 | render_open_a_span(MD_HTML* r, const MD_SPAN_A_DETAIL* det)
328 | {
329 |     RENDER_VERBATIM(r, "<a href=\"");
330 |     render_attribute(r, &det->href, render_url_escaped);
331 | 
332 |     if(det->title.text != NULL) {
333 |         RENDER_VERBATIM(r, "\" title=\"");
334 |         render_attribute(r, &det->title, render_html_escaped);
335 |     }
336 | 
337 |     RENDER_VERBATIM(r, "\">");
338 | }
339 | 
340 | static void
341 | render_open_img_span(MD_HTML* r, const MD_SPAN_IMG_DETAIL* det)
342 | {
343 |     RENDER_VERBATIM(r, "<img src=\"");
344 |     render_attribute(r, &det->src, render_url_escaped);
345 | 
346 |     RENDER_VERBATIM(r, "\" alt=\"");
347 | }
348 | 
349 | static void
350 | render_close_img_span(MD_HTML* r, const MD_SPAN_IMG_DETAIL* det)
351 | {
352 |     if(det->title.text != NULL) {
353 |         RENDER_VERBATIM(r, "\" title=\"");
354 |         render_attribute(r, &det->title, render_html_escaped);
355 |     }
356 | 
357 |     RENDER_VERBATIM(r, (r->flags & MD_HTML_FLAG_XHTML) ? "\" />" : "\">");
358 | }
359 | 
360 | static void
361 | render_open_wikilink_span(MD_HTML* r, const MD_SPAN_WIKILINK_DETAIL* det)
362 | {
363 |     RENDER_VERBATIM(r, "<x-wikilink data-target=\"");
364 |     render_attribute(r, &det->target, render_html_escaped);
365 | 
366 |     RENDER_VERBATIM(r, "\">");
367 | }
368 | 
369 | 
370 | /**************************************
371 |  ***  HTML renderer implementation  ***
372 |  **************************************/
373 | 
374 | static int
375 | enter_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata)
376 | {
377 |     static const MD_CHAR* head[6] = { "<h1>", "<h2>", "<h3>", "<h4>", "<h5>", "<h6>" };
378 |     MD_HTML* r = (MD_HTML*) userdata;
379 | 
380 |     switch(type) {
381 |         case MD_BLOCK_DOC:      /* noop */ break;
382 |         case MD_BLOCK_QUOTE:    RENDER_VERBATIM(r, "<blockquote>\n"); break;
383 |         case MD_BLOCK_UL:       RENDER_VERBATIM(r, "<ul>\n"); break;
384 |         case MD_BLOCK_OL:       render_open_ol_block(r, (const MD_BLOCK_OL_DETAIL*)detail); break;
385 |         case MD_BLOCK_LI:       render_open_li_block(r, (const MD_BLOCK_LI_DETAIL*)detail); break;
386 |         case MD_BLOCK_HR:       RENDER_VERBATIM(r, (r->flags & MD_HTML_FLAG_XHTML) ? "<hr />\n" : "<hr>\n"); break;
387 |         case MD_BLOCK_H:        RENDER_VERBATIM(r, head[((MD_BLOCK_H_DETAIL*)detail)->level - 1]); break;
388 |         case MD_BLOCK_CODE:     render_open_code_block(r, (const MD_BLOCK_CODE_DETAIL*) detail); break;
389 |         case MD_BLOCK_HTML:     /* noop */ break;
390 |         case MD_BLOCK_P:        RENDER_VERBATIM(r, "<p>"); break;
391 |         case MD_BLOCK_TABLE:    RENDER_VERBATIM(r, "<table>\n"); break;
392 |         case MD_BLOCK_THEAD:    RENDER_VERBATIM(r, "<thead>\n"); break;
393 |         case MD_BLOCK_TBODY:    RENDER_VERBATIM(r, "<tbody>\n"); break;
394 |         case MD_BLOCK_TR:       RENDER_VERBATIM(r, "<tr>\n"); break;
395 |         case MD_BLOCK_TH:       render_open_td_block(r, "th", (MD_BLOCK_TD_DETAIL*)detail); break;
396 |         case MD_BLOCK_TD:       render_open_td_block(r, "td", (MD_BLOCK_TD_DETAIL*)detail); break;
397 |     }
398 | 
399 |     return 0;
400 | }
401 | 
402 | static int
403 | leave_block_callback(MD_BLOCKTYPE type, void* detail, void* userdata)
404 | {
405 |     static const MD_CHAR* head[6] = { "</h1>\n", "</h2>\n", "</h3>\n", "</h4>\n", "</h5>\n", "</h6>\n" };
406 |     MD_HTML* r = (MD_HTML*) userdata;
407 | 
408 |     switch(type) {
409 |         case MD_BLOCK_DOC:      /*noop*/ break;
410 |         case MD_BLOCK_QUOTE:    RENDER_VERBATIM(r, "</blockquote>\n"); break;
411 |         case MD_BLOCK_UL:       RENDER_VERBATIM(r, "</ul>\n"); break;
412 |         case MD_BLOCK_OL:       RENDER_VERBATIM(r, "</ol>\n"); break;
413 |         case MD_BLOCK_LI:       RENDER_VERBATIM(r, "</li>\n"); break;
414 |         case MD_BLOCK_HR:       /*noop*/ break;
415 |         case MD_BLOCK_H:        RENDER_VERBATIM(r, head[((MD_BLOCK_H_DETAIL*)detail)->level - 1]); break;
416 |         case MD_BLOCK_CODE:     RENDER_VERBATIM(r, "</code></pre>\n"); break;
417 |         case MD_BLOCK_HTML:     /* noop */ break;
418 |         case MD_BLOCK_P:        RENDER_VERBATIM(r, "</p>\n"); break;
419 |         case MD_BLOCK_TABLE:    RENDER_VERBATIM(r, "</table>\n"); break;
420 |         case MD_BLOCK_THEAD:    RENDER_VERBATIM(r, "</thead>\n"); break;
421 |         case MD_BLOCK_TBODY:    RENDER_VERBATIM(r, "</tbody>\n"); break;
422 |         case MD_BLOCK_TR:       RENDER_VERBATIM(r, "</tr>\n"); break;
423 |         case MD_BLOCK_TH:       RENDER_VERBATIM(r, "</th>\n"); break;
424 |         case MD_BLOCK_TD:       RENDER_VERBATIM(r, "</td>\n"); break;
425 |     }
426 | 
427 |     return 0;
428 | }
429 | 
430 | static int
431 | enter_span_callback(MD_SPANTYPE type, void* detail, void* userdata)
432 | {
433 |     MD_HTML* r = (MD_HTML*) userdata;
434 |     int inside_img = (r->image_nesting_level > 0);
435 | 
436 |     /* We are inside a Markdown image label. Markdown allows to use any emphasis
437 |      * and other rich contents in that context similarly as in any link label.
438 |      *
439 |      * However, unlike in the case of links (where that contents becomescontents
440 |      * of the <a>...</a> tag), in the case of images the contents is supposed to
441 |      * fall into the attribute alt: <img alt="...">.
442 |      *
443 |      * In that context we naturally cannot output nested HTML tags. So lets
444 |      * suppress them and only output the plain text (i.e. what falls into text()
445 |      * callback).
446 |      *
447 |      * CommonMark specification declares this a recommended practice for HTML
448 |      * output.
449 |      */
450 |     if(type == MD_SPAN_IMG)
451 |         r->image_nesting_level++;
452 |     if(inside_img)
453 |         return 0;
454 | 
455 |     switch(type) {
456 |         case MD_SPAN_EM:                RENDER_VERBATIM(r, "<em>"); break;
457 |         case MD_SPAN_STRONG:            RENDER_VERBATIM(r, "<strong>"); break;
458 |         case MD_SPAN_U:                 RENDER_VERBATIM(r, "<u>"); break;
459 |         case MD_SPAN_A:                 render_open_a_span(r, (MD_SPAN_A_DETAIL*) detail); break;
460 |         case MD_SPAN_IMG:               render_open_img_span(r, (MD_SPAN_IMG_DETAIL*) detail); break;
461 |         case MD_SPAN_CODE:              RENDER_VERBATIM(r, "<code>"); break;
462 |         case MD_SPAN_DEL:               RENDER_VERBATIM(r, "<del>"); break;
463 |         case MD_SPAN_LATEXMATH:         RENDER_VERBATIM(r, "<x-equation>"); break;
464 |         case MD_SPAN_LATEXMATH_DISPLAY: RENDER_VERBATIM(r, "<x-equation type=\"display\">"); break;
465 |         case MD_SPAN_WIKILINK:          render_open_wikilink_span(r, (MD_SPAN_WIKILINK_DETAIL*) detail); break;
466 |     }
467 | 
468 |     return 0;
469 | }
470 | 
471 | static int
472 | leave_span_callback(MD_SPANTYPE type, void* detail, void* userdata)
473 | {
474 |     MD_HTML* r = (MD_HTML*) userdata;
475 | 
476 |     if(type == MD_SPAN_IMG)
477 |         r->image_nesting_level--;
478 |     if(r->image_nesting_level > 0)
479 |         return 0;
480 | 
481 |     switch(type) {
482 |         case MD_SPAN_EM:                RENDER_VERBATIM(r, "</em>"); break;
483 |         case MD_SPAN_STRONG:            RENDER_VERBATIM(r, "</strong>"); break;
484 |         case MD_SPAN_U:                 RENDER_VERBATIM(r, "</u>"); break;
485 |         case MD_SPAN_A:                 RENDER_VERBATIM(r, "</a>"); break;
486 |         case MD_SPAN_IMG:               render_close_img_span(r, (MD_SPAN_IMG_DETAIL*) detail); break;
487 |         case MD_SPAN_CODE:              RENDER_VERBATIM(r, "</code>"); break;
488 |         case MD_SPAN_DEL:               RENDER_VERBATIM(r, "</del>"); break;
489 |         case MD_SPAN_LATEXMATH:         /*fall through*/
490 |         case MD_SPAN_LATEXMATH_DISPLAY: RENDER_VERBATIM(r, "</x-equation>"); break;
491 |         case MD_SPAN_WIKILINK:          RENDER_VERBATIM(r, "</x-wikilink>"); break;
492 |     }
493 | 
494 |     return 0;
495 | }
496 | 
497 | static int
498 | text_callback(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* userdata)
499 | {
500 |     MD_HTML* r = (MD_HTML*) userdata;
501 | 
502 |     switch(type) {
503 |         case MD_TEXT_NULLCHAR:  render_utf8_codepoint(r, 0x0000, render_verbatim); break;
504 |         case MD_TEXT_BR:        RENDER_VERBATIM(r, (r->image_nesting_level == 0
505 |                                         ? ((r->flags & MD_HTML_FLAG_XHTML) ? "<br />\n" : "<br>\n")
506 |                                         : " "));
507 |                                 break;
508 |         case MD_TEXT_SOFTBR:    RENDER_VERBATIM(r, (r->image_nesting_level == 0 ? "\n" : " ")); break;
509 |         case MD_TEXT_HTML:      render_verbatim(r, text, size); break;
510 |         case MD_TEXT_ENTITY:    render_entity(r, text, size, render_html_escaped); break;
511 |         default:                render_html_escaped(r, text, size); break;
512 |     }
513 | 
514 |     return 0;
515 | }
516 | 
517 | static void
518 | debug_log_callback(const char* msg, void* userdata)
519 | {
520 |     MD_HTML* r = (MD_HTML*) userdata;
521 |     if(r->flags & MD_HTML_FLAG_DEBUG)
522 |         fprintf(stderr, "MD4C: %s\n", msg);
523 | }
524 | 
525 | int
526 | md_html(const MD_CHAR* input, MD_SIZE input_size,
527 |         void (*process_output)(const MD_CHAR*, MD_SIZE, void*),
528 |         void* userdata, unsigned parser_flags, unsigned renderer_flags)
529 | {
530 |     MD_HTML render = { process_output, userdata, renderer_flags, 0, { 0 } };
531 |     int i;
532 | 
533 |     MD_PARSER parser = {
534 |         0,
535 |         parser_flags,
536 |         enter_block_callback,
537 |         leave_block_callback,
538 |         enter_span_callback,
539 |         leave_span_callback,
540 |         text_callback,
541 |         debug_log_callback,
542 |         NULL
543 |     };
544 | 
545 |     /* Build map of characters which need escaping. */
546 |     for(i = 0; i < 256; i++) {
547 |         unsigned char ch = (unsigned char) i;
548 | 
549 |         if(strchr("\"&<>", ch) != NULL)
550 |             render.escape_map[i] |= NEED_HTML_ESC_FLAG;
551 | 
552 |         if(!ISALNUM(ch)  &&  strchr("~-_.+!*(),%#@?=;:/,+$", ch) == NULL)
553 |             render.escape_map[i] |= NEED_URL_ESC_FLAG;
554 |     }
555 | 
556 |     /* Consider skipping UTF-8 byte order mark (BOM). */
557 |     if(renderer_flags & MD_HTML_FLAG_SKIP_UTF8_BOM  &&  sizeof(MD_CHAR) == 1) {
558 |         static const MD_CHAR bom[3] = { (char)0xef, (char)0xbb, (char)0xbf };
559 |         if(input_size >= sizeof(bom)  &&  memcmp(input, bom, sizeof(bom)) == 0) {
560 |             input += sizeof(bom);
561 |             input_size -= sizeof(bom);
562 |         }
563 |     }
564 | 
565 |     return md_parse(input, input_size, &parser, (void*) &render);
566 | }
567 | 
568 | 


--------------------------------------------------------------------------------
/src/md4c-html.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * MD4C: Markdown parser for C
 3 |  * (http://github.com/mity/md4c)
 4 |  *
 5 |  * Copyright (c) 2016-2024 Martin Mitáš
 6 |  *
 7 |  * Permission is hereby granted, free of charge, to any person obtaining a
 8 |  * copy of this software and associated documentation files (the "Software"),
 9 |  * to deal in the Software without restriction, including without limitation
10 |  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 |  * and/or sell copies of the Software, and to permit persons to whom the
12 |  * Software is furnished to do so, subject to the following conditions:
13 |  *
14 |  * The above copyright notice and this permission notice shall be included in
15 |  * all copies or substantial portions of the Software.
16 |  *
17 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 |  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 |  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
23 |  * IN THE SOFTWARE.
24 |  */
25 | 
26 | #ifndef MD4C_HTML_H
27 | #define MD4C_HTML_H
28 | 
29 | #include "md4c.h"
30 | 
31 | #ifdef __cplusplus
32 |     extern "C" {
33 | #endif
34 | 
35 | 
36 | /* If set, debug output from md_parse() is sent to stderr. */
37 | #define MD_HTML_FLAG_DEBUG                  0x0001
38 | #define MD_HTML_FLAG_VERBATIM_ENTITIES      0x0002
39 | #define MD_HTML_FLAG_SKIP_UTF8_BOM          0x0004
40 | #define MD_HTML_FLAG_XHTML                  0x0008
41 | 
42 | 
43 | /* Render Markdown into HTML.
44 |  *
45 |  * Note only contents of <body> tag is generated. Caller must generate
46 |  * HTML header/footer manually before/after calling md_html().
47 |  *
48 |  * Params input and input_size specify the Markdown input.
49 |  * Callback process_output() gets called with chunks of HTML output.
50 |  * (Typical implementation may just output the bytes to a file or append to
51 |  * some buffer).
52 |  * Param userdata is just propagated back to process_output() callback.
53 |  * Param parser_flags are flags from md4c.h propagated to md_parse().
54 |  * Param render_flags is bitmask of MD_HTML_FLAG_xxxx.
55 |  *
56 |  * Returns -1 on error (if md_parse() fails.)
57 |  * Returns 0 on success.
58 |  */
59 | int md_html(const MD_CHAR* input, MD_SIZE input_size,
60 |             void (*process_output)(const MD_CHAR*, MD_SIZE, void*),
61 |             void* userdata, unsigned parser_flags, unsigned renderer_flags);
62 | 
63 | 
64 | #ifdef __cplusplus
65 |     }  /* extern "C" { */
66 | #endif
67 | 
68 | #endif  /* MD4C_HTML_H */
69 | 


--------------------------------------------------------------------------------
/src/md4c-html.pc.in:
--------------------------------------------------------------------------------
 1 | prefix=@CMAKE_INSTALL_PREFIX@
 2 | exec_prefix=@CMAKE_INSTALL_PREFIX@
 3 | libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@
 4 | includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
 5 | 
 6 | Name: @PROJECT_NAME@ HTML renderer
 7 | Description: Markdown to HTML converter library.
 8 | Version: @PROJECT_VERSION@
 9 | URL: @PROJECT_URL@
10 | 
11 | Requires: md4c = @PROJECT_VERSION@
12 | Libs: -L${libdir} -lmd4c-html
13 | Cflags: -I${includedir}
14 | 


--------------------------------------------------------------------------------
/src/md4c.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * MD4C: Markdown parser for C
  3 |  * (http://github.com/mity/md4c)
  4 |  *
  5 |  * Copyright (c) 2016-2024 Martin Mitáš
  6 |  *
  7 |  * Permission is hereby granted, free of charge, to any person obtaining a
  8 |  * copy of this software and associated documentation files (the "Software"),
  9 |  * to deal in the Software without restriction, including without limitation
 10 |  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 11 |  * and/or sell copies of the Software, and to permit persons to whom the
 12 |  * Software is furnished to do so, subject to the following conditions:
 13 |  *
 14 |  * The above copyright notice and this permission notice shall be included in
 15 |  * all copies or substantial portions of the Software.
 16 |  *
 17 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 18 |  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 19 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 20 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 21 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 22 |  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 23 |  * IN THE SOFTWARE.
 24 |  */
 25 | 
 26 | #ifndef MD4C_H
 27 | #define MD4C_H
 28 | 
 29 | #ifdef __cplusplus
 30 |     extern "C" {
 31 | #endif
 32 | 
 33 | #if defined MD4C_USE_UTF16
 34 |     /* Magic to support UTF-16. Note that in order to use it, you have to define
 35 |      * the macro MD4C_USE_UTF16 both when building MD4C as well as when
 36 |      * including this header in your code. */
 37 |     #ifdef _WIN32
 38 |         #include <windows.h>
 39 |         typedef WCHAR       MD_CHAR;
 40 |     #else
 41 |         #error MD4C_USE_UTF16 is only supported on Windows.
 42 |     #endif
 43 | #else
 44 |     typedef char            MD_CHAR;
 45 | #endif
 46 | 
 47 | typedef unsigned MD_SIZE;
 48 | typedef unsigned MD_OFFSET;
 49 | 
 50 | 
 51 | /* Block represents a part of document hierarchy structure like a paragraph
 52 |  * or list item.
 53 |  */
 54 | typedef enum MD_BLOCKTYPE {
 55 |     /* <body>...</body> */
 56 |     MD_BLOCK_DOC = 0,
 57 | 
 58 |     /* <blockquote>...</blockquote> */
 59 |     MD_BLOCK_QUOTE,
 60 | 
 61 |     /* <ul>...</ul>
 62 |      * Detail: Structure MD_BLOCK_UL_DETAIL. */
 63 |     MD_BLOCK_UL,
 64 | 
 65 |     /* <ol>...</ol>
 66 |      * Detail: Structure MD_BLOCK_OL_DETAIL. */
 67 |     MD_BLOCK_OL,
 68 | 
 69 |     /* <li>...</li>
 70 |      * Detail: Structure MD_BLOCK_LI_DETAIL. */
 71 |     MD_BLOCK_LI,
 72 | 
 73 |     /* <hr> */
 74 |     MD_BLOCK_HR,
 75 | 
 76 |     /* <h1>...</h1> (for levels up to 6)
 77 |      * Detail: Structure MD_BLOCK_H_DETAIL. */
 78 |     MD_BLOCK_H,
 79 | 
 80 |     /* <pre><code>...</code></pre>
 81 |      * Note the text lines within code blocks are terminated with '\n'
 82 |      * instead of explicit MD_TEXT_BR. */
 83 |     MD_BLOCK_CODE,
 84 | 
 85 |     /* Raw HTML block. This itself does not correspond to any particular HTML
 86 |      * tag. The contents of it _is_ raw HTML source intended to be put
 87 |      * in verbatim form to the HTML output. */
 88 |     MD_BLOCK_HTML,
 89 | 
 90 |     /* <p>...</p> */
 91 |     MD_BLOCK_P,
 92 | 
 93 |     /* <table>...</table> and its contents.
 94 |      * Detail: Structure MD_BLOCK_TABLE_DETAIL (for MD_BLOCK_TABLE),
 95 |      *         structure MD_BLOCK_TD_DETAIL (for MD_BLOCK_TH and MD_BLOCK_TD)
 96 |      * Note all of these are used only if extension MD_FLAG_TABLES is enabled. */
 97 |     MD_BLOCK_TABLE,
 98 |     MD_BLOCK_THEAD,
 99 |     MD_BLOCK_TBODY,
100 |     MD_BLOCK_TR,
101 |     MD_BLOCK_TH,
102 |     MD_BLOCK_TD
103 | } MD_BLOCKTYPE;
104 | 
105 | /* Span represents an in-line piece of a document which should be rendered with
106 |  * the same font, color and other attributes. A sequence of spans forms a block
107 |  * like paragraph or list item. */
108 | typedef enum MD_SPANTYPE {
109 |     /* <em>...</em> */
110 |     MD_SPAN_EM,
111 | 
112 |     /* <strong>...</strong> */
113 |     MD_SPAN_STRONG,
114 | 
115 |     /* <a href="xxx">...</a>
116 |      * Detail: Structure MD_SPAN_A_DETAIL. */
117 |     MD_SPAN_A,
118 | 
119 |     /* <img src="xxx">...</a>
120 |      * Detail: Structure MD_SPAN_IMG_DETAIL.
121 |      * Note: Image text can contain nested spans and even nested images.
122 |      * If rendered into ALT attribute of HTML <IMG> tag, it's responsibility
123 |      * of the parser to deal with it.
124 |      */
125 |     MD_SPAN_IMG,
126 | 
127 |     /* <code>...</code> */
128 |     MD_SPAN_CODE,
129 | 
130 |     /* <del>...</del>
131 |      * Note: Recognized only when MD_FLAG_STRIKETHROUGH is enabled.
132 |      */
133 |     MD_SPAN_DEL,
134 | 
135 |     /* For recognizing inline ($) and display ($$) equations
136 |      * Note: Recognized only when MD_FLAG_LATEXMATHSPANS is enabled.
137 |      */
138 |     MD_SPAN_LATEXMATH,
139 |     MD_SPAN_LATEXMATH_DISPLAY,
140 | 
141 |     /* Wiki links
142 |      * Note: Recognized only when MD_FLAG_WIKILINKS is enabled.
143 |      */
144 |     MD_SPAN_WIKILINK,
145 | 
146 |     /* <u>...</u>
147 |      * Note: Recognized only when MD_FLAG_UNDERLINE is enabled. */
148 |     MD_SPAN_U
149 | } MD_SPANTYPE;
150 | 
151 | /* Text is the actual textual contents of span. */
152 | typedef enum MD_TEXTTYPE {
153 |     /* Normal text. */
154 |     MD_TEXT_NORMAL = 0,
155 | 
156 |     /* NULL character. CommonMark requires replacing NULL character with
157 |      * the replacement char U+FFFD, so this allows caller to do that easily. */
158 |     MD_TEXT_NULLCHAR,
159 | 
160 |     /* Line breaks.
161 |      * Note these are not sent from blocks with verbatim output (MD_BLOCK_CODE
162 |      * or MD_BLOCK_HTML). In such cases, '\n' is part of the text itself. */
163 |     MD_TEXT_BR,         /* <br> (hard break) */
164 |     MD_TEXT_SOFTBR,     /* '\n' in source text where it is not semantically meaningful (soft break) */
165 | 
166 |     /* Entity.
167 |      * (a) Named entity, e.g. &nbsp; 
168 |      *     (Note MD4C does not have a list of known entities.
169 |      *     Anything matching the regexp /&[A-Za-z][A-Za-z0-9]{1,47};/ is
170 |      *     treated as a named entity.)
171 |      * (b) Numerical entity, e.g. &#1234;
172 |      * (c) Hexadecimal entity, e.g. &#x12AB;
173 |      *
174 |      * As MD4C is mostly encoding agnostic, application gets the verbatim
175 |      * entity text into the MD_PARSER::text_callback(). */
176 |     MD_TEXT_ENTITY,
177 | 
178 |     /* Text in a code block (inside MD_BLOCK_CODE) or inlined code (`code`).
179 |      * If it is inside MD_BLOCK_CODE, it includes spaces for indentation and
180 |      * '\n' for new lines. MD_TEXT_BR and MD_TEXT_SOFTBR are not sent for this
181 |      * kind of text. */
182 |     MD_TEXT_CODE,
183 | 
184 |     /* Text is a raw HTML. If it is contents of a raw HTML block (i.e. not
185 |      * an inline raw HTML), then MD_TEXT_BR and MD_TEXT_SOFTBR are not used.
186 |      * The text contains verbatim '\n' for the new lines. */
187 |     MD_TEXT_HTML,
188 | 
189 |     /* Text is inside an equation. This is processed the same way as inlined code
190 |      * spans (`code`). */
191 |     MD_TEXT_LATEXMATH
192 | } MD_TEXTTYPE;
193 | 
194 | 
195 | /* Alignment enumeration. */
196 | typedef enum MD_ALIGN {
197 |     MD_ALIGN_DEFAULT = 0,   /* When unspecified. */
198 |     MD_ALIGN_LEFT,
199 |     MD_ALIGN_CENTER,
200 |     MD_ALIGN_RIGHT
201 | } MD_ALIGN;
202 | 
203 | 
204 | /* String attribute.
205 |  *
206 |  * This wraps strings which are outside of a normal text flow and which are
207 |  * propagated within various detailed structures, but which still may contain
208 |  * string portions of different types like e.g. entities.
209 |  *
210 |  * So, for example, lets consider this image:
211 |  *
212 |  *     ![image alt text](http://example.org/image.png 'foo &quot; bar')
213 |  *
214 |  * The image alt text is propagated as a normal text via the MD_PARSER::text()
215 |  * callback. However, the image title ('foo &quot; bar') is propagated as
216 |  * MD_ATTRIBUTE in MD_SPAN_IMG_DETAIL::title.
217 |  *
218 |  * Then the attribute MD_SPAN_IMG_DETAIL::title shall provide the following:
219 |  *  -- [0]: "foo "   (substr_types[0] == MD_TEXT_NORMAL; substr_offsets[0] == 0)
220 |  *  -- [1]: "&quot;" (substr_types[1] == MD_TEXT_ENTITY; substr_offsets[1] == 4)
221 |  *  -- [2]: " bar"   (substr_types[2] == MD_TEXT_NORMAL; substr_offsets[2] == 10)
222 |  *  -- [3]: (n/a)    (n/a                              ; substr_offsets[3] == 14)
223 |  *
224 |  * Note that these invariants are always guaranteed:
225 |  *  -- substr_offsets[0] == 0
226 |  *  -- substr_offsets[LAST+1] == size
227 |  *  -- Currently, only MD_TEXT_NORMAL, MD_TEXT_ENTITY, MD_TEXT_NULLCHAR
228 |  *     substrings can appear. This could change only of the specification
229 |  *     changes.
230 |  */
231 | typedef struct MD_ATTRIBUTE {
232 |     const MD_CHAR* text;
233 |     MD_SIZE size;
234 |     const MD_TEXTTYPE* substr_types;
235 |     const MD_OFFSET* substr_offsets;
236 | } MD_ATTRIBUTE;
237 | 
238 | 
239 | /* Detailed info for MD_BLOCK_UL. */
240 | typedef struct MD_BLOCK_UL_DETAIL {
241 |     int is_tight;           /* Non-zero if tight list, zero if loose. */
242 |     MD_CHAR mark;           /* Item bullet character in MarkDown source of the list, e.g. '-', '+', '*'. */
243 | } MD_BLOCK_UL_DETAIL;
244 | 
245 | /* Detailed info for MD_BLOCK_OL. */
246 | typedef struct MD_BLOCK_OL_DETAIL {
247 |     unsigned start;         /* Start index of the ordered list. */
248 |     int is_tight;           /* Non-zero if tight list, zero if loose. */
249 |     MD_CHAR mark_delimiter; /* Character delimiting the item marks in MarkDown source, e.g. '.' or ')' */
250 | } MD_BLOCK_OL_DETAIL;
251 | 
252 | /* Detailed info for MD_BLOCK_LI. */
253 | typedef struct MD_BLOCK_LI_DETAIL {
254 |     int is_task;            /* Can be non-zero only with MD_FLAG_TASKLISTS */
255 |     MD_CHAR task_mark;      /* If is_task, then one of 'x', 'X' or ' '. Undefined otherwise. */
256 |     MD_OFFSET task_mark_offset;  /* If is_task, then offset in the input of the char between '[' and ']'. */
257 | } MD_BLOCK_LI_DETAIL;
258 | 
259 | /* Detailed info for MD_BLOCK_H. */
260 | typedef struct MD_BLOCK_H_DETAIL {
261 |     unsigned level;         /* Header level (1 - 6) */
262 | } MD_BLOCK_H_DETAIL;
263 | 
264 | /* Detailed info for MD_BLOCK_CODE. */
265 | typedef struct MD_BLOCK_CODE_DETAIL {
266 |     MD_ATTRIBUTE info;
267 |     MD_ATTRIBUTE lang;
268 |     MD_CHAR fence_char;     /* The character used for fenced code block; or zero for indented code block. */
269 | } MD_BLOCK_CODE_DETAIL;
270 | 
271 | /* Detailed info for MD_BLOCK_TABLE. */
272 | typedef struct MD_BLOCK_TABLE_DETAIL {
273 |     unsigned col_count;         /* Count of columns in the table. */
274 |     unsigned head_row_count;    /* Count of rows in the table header (currently always 1) */
275 |     unsigned body_row_count;    /* Count of rows in the table body */
276 | } MD_BLOCK_TABLE_DETAIL;
277 | 
278 | /* Detailed info for MD_BLOCK_TH and MD_BLOCK_TD. */
279 | typedef struct MD_BLOCK_TD_DETAIL {
280 |     MD_ALIGN align;
281 | } MD_BLOCK_TD_DETAIL;
282 | 
283 | /* Detailed info for MD_SPAN_A. */
284 | typedef struct MD_SPAN_A_DETAIL {
285 |     MD_ATTRIBUTE href;
286 |     MD_ATTRIBUTE title;
287 |     int is_autolink;            /* nonzero if this is an autolink */
288 | } MD_SPAN_A_DETAIL;
289 | 
290 | /* Detailed info for MD_SPAN_IMG. */
291 | typedef struct MD_SPAN_IMG_DETAIL {
292 |     MD_ATTRIBUTE src;
293 |     MD_ATTRIBUTE title;
294 | } MD_SPAN_IMG_DETAIL;
295 | 
296 | /* Detailed info for MD_SPAN_WIKILINK. */
297 | typedef struct MD_SPAN_WIKILINK {
298 |     MD_ATTRIBUTE target;
299 | } MD_SPAN_WIKILINK_DETAIL;
300 | 
301 | /* Flags specifying extensions/deviations from CommonMark specification.
302 |  *
303 |  * By default (when MD_PARSER::flags == 0), we follow CommonMark specification.
304 |  * The following flags may allow some extensions or deviations from it.
305 |  */
306 | #define MD_FLAG_COLLAPSEWHITESPACE          0x0001  /* In MD_TEXT_NORMAL, collapse non-trivial whitespace into single ' ' */
307 | #define MD_FLAG_PERMISSIVEATXHEADERS        0x0002  /* Do not require space in ATX headers ( ###header ) */
308 | #define MD_FLAG_PERMISSIVEURLAUTOLINKS      0x0004  /* Recognize URLs as autolinks even without '<', '>' */
309 | #define MD_FLAG_PERMISSIVEEMAILAUTOLINKS    0x0008  /* Recognize e-mails as autolinks even without '<', '>' and 'mailto:' */
310 | #define MD_FLAG_NOINDENTEDCODEBLOCKS        0x0010  /* Disable indented code blocks. (Only fenced code works.) */
311 | #define MD_FLAG_NOHTMLBLOCKS                0x0020  /* Disable raw HTML blocks. */
312 | #define MD_FLAG_NOHTMLSPANS                 0x0040  /* Disable raw HTML (inline). */
313 | #define MD_FLAG_TABLES                      0x0100  /* Enable tables extension. */
314 | #define MD_FLAG_STRIKETHROUGH               0x0200  /* Enable strikethrough extension. */
315 | #define MD_FLAG_PERMISSIVEWWWAUTOLINKS      0x0400  /* Enable WWW autolinks (even without any scheme prefix, if they begin with 'www.') */
316 | #define MD_FLAG_TASKLISTS                   0x0800  /* Enable task list extension. */
317 | #define MD_FLAG_LATEXMATHSPANS              0x1000  /* Enable $ and $$ containing LaTeX equations. */
318 | #define MD_FLAG_WIKILINKS                   0x2000  /* Enable wiki links extension. */
319 | #define MD_FLAG_UNDERLINE                   0x4000  /* Enable underline extension (and disables '_' for normal emphasis). */
320 | #define MD_FLAG_HARD_SOFT_BREAKS            0x8000  /* Force all soft breaks to act as hard breaks. */
321 | 
322 | #define MD_FLAG_PERMISSIVEAUTOLINKS         (MD_FLAG_PERMISSIVEEMAILAUTOLINKS | MD_FLAG_PERMISSIVEURLAUTOLINKS | MD_FLAG_PERMISSIVEWWWAUTOLINKS)
323 | #define MD_FLAG_NOHTML                      (MD_FLAG_NOHTMLBLOCKS | MD_FLAG_NOHTMLSPANS)
324 | 
325 | /* Convenient sets of flags corresponding to well-known Markdown dialects.
326 |  *
327 |  * Note we may only support subset of features of the referred dialect.
328 |  * The constant just enables those extensions which bring us as close as
329 |  * possible given what features we implement.
330 |  *
331 |  * ABI compatibility note: Meaning of these can change in time as new
332 |  * extensions, bringing the dialect closer to the original, are implemented.
333 |  */
334 | #define MD_DIALECT_COMMONMARK               0
335 | #define MD_DIALECT_GITHUB                   (MD_FLAG_PERMISSIVEAUTOLINKS | MD_FLAG_TABLES | MD_FLAG_STRIKETHROUGH | MD_FLAG_TASKLISTS)
336 | 
337 | /* Parser structure.
338 |  */
339 | typedef struct MD_PARSER {
340 |     /* Reserved. Set to zero.
341 |      */
342 |     unsigned abi_version;
343 | 
344 |     /* Dialect options. Bitmask of MD_FLAG_xxxx values.
345 |      */
346 |     unsigned flags;
347 | 
348 |     /* Caller-provided rendering callbacks.
349 |      *
350 |      * For some block/span types, more detailed information is provided in a
351 |      * type-specific structure pointed by the argument 'detail'.
352 |      *
353 |      * The last argument of all callbacks, 'userdata', is just propagated from
354 |      * md_parse() and is available for any use by the application.
355 |      *
356 |      * Note any strings provided to the callbacks as their arguments or as
357 |      * members of any detail structure are generally not zero-terminated.
358 |      * Application has to take the respective size information into account.
359 |      *
360 |      * Any rendering callback may abort further parsing of the document by
361 |      * returning non-zero.
362 |      */
363 |     int (*enter_block)(MD_BLOCKTYPE /*type*/, void* /*detail*/, void* /*userdata*/);
364 |     int (*leave_block)(MD_BLOCKTYPE /*type*/, void* /*detail*/, void* /*userdata*/);
365 | 
366 |     int (*enter_span)(MD_SPANTYPE /*type*/, void* /*detail*/, void* /*userdata*/);
367 |     int (*leave_span)(MD_SPANTYPE /*type*/, void* /*detail*/, void* /*userdata*/);
368 | 
369 |     int (*text)(MD_TEXTTYPE /*type*/, const MD_CHAR* /*text*/, MD_SIZE /*size*/, void* /*userdata*/);
370 | 
371 |     /* Debug callback. Optional (may be NULL).
372 |      *
373 |      * If provided and something goes wrong, this function gets called.
374 |      * This is intended for debugging and problem diagnosis for developers;
375 |      * it is not intended to provide any errors suitable for displaying to an
376 |      * end user.
377 |      */
378 |     void (*debug_log)(const char* /*msg*/, void* /*userdata*/);
379 | 
380 |     /* Reserved. Set to NULL.
381 |      */
382 |     void (*syntax)(void);
383 | } MD_PARSER;
384 | 
385 | 
386 | /* For backward compatibility. Do not use in new code.
387 |  */
388 | typedef MD_PARSER MD_RENDERER;
389 | 
390 | 
391 | /* Parse the Markdown document stored in the string 'text' of size 'size'.
392 |  * The parser provides callbacks to be called during the parsing so the
393 |  * caller can render the document on the screen or convert the Markdown
394 |  * to another format.
395 |  *
396 |  * Zero is returned on success. If a runtime error occurs (e.g. a memory
397 |  * fails), -1 is returned. If the processing is aborted due any callback
398 |  * returning non-zero, the return value of the callback is returned.
399 |  */
400 | int md_parse(const MD_CHAR* text, MD_SIZE size, const MD_PARSER* parser, void* userdata);
401 | 
402 | 
403 | #ifdef __cplusplus
404 |     }  /* extern "C" { */
405 | #endif
406 | 
407 | #endif  /* MD4C_H */
408 | 


--------------------------------------------------------------------------------
/src/md4c.pc.in:
--------------------------------------------------------------------------------
 1 | prefix=@CMAKE_INSTALL_PREFIX@
 2 | exec_prefix=@CMAKE_INSTALL_PREFIX@
 3 | libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@
 4 | includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
 5 | 
 6 | Name: @PROJECT_NAME@
 7 | Description: Markdown parser library with a SAX-like callback-based interface.
 8 | Version: @PROJECT_VERSION@
 9 | URL: @PROJECT_URL@
10 | 
11 | Requires:
12 | Libs: -L${libdir} -lmd4c
13 | Cflags: -I${includedir}
14 | 


--------------------------------------------------------------------------------
/test/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The CommonMark spec (spec.txt) and DTD (CommonMark.dtd) are
 2 | 
 3 | Copyright (C) 2014-16 John MacFarlane
 4 | 
 5 | Released under the Creative Commons CC-BY-SA 4.0 license:
 6 | <http://creativecommons.org/licenses/by-sa/4.0/>.
 7 | 
 8 | ---
 9 | 
10 | The test software in test/ and the programs in tools/ are
11 | 
12 | Copyright (c) 2014, John MacFarlane
13 | 
14 | All rights reserved.
15 | 
16 | Redistribution and use in source and binary forms, with or without
17 | modification, are permitted provided that the following conditions are met:
18 | 
19 |     * Redistributions of source code must retain the above copyright
20 |       notice, this list of conditions and the following disclaimer.
21 | 
22 |     * Redistributions in binary form must reproduce the above
23 |       copyright notice, this list of conditions and the following
24 |       disclaimer in the documentation and/or other materials provided
25 |       with the distribution.
26 | 
27 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 | 
39 | ---
40 | 
41 | The normalization code in normalize.py was derived from the markdowntest
42 | project, Copyright 2013 Karl Dubost:
43 | 
44 | The MIT License (MIT)
45 | 
46 | Copyright (c) 2013 Karl Dubost
47 | 
48 | Permission is hereby granted, free of charge, to any person obtaining a copy
49 | of this software and associated documentation files (the "Software"), to deal
50 | in the Software without restriction, including without limitation the rights
51 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
52 | copies of the Software, and to permit persons to whom the Software is
53 | furnished to do so, subject to the following conditions:
54 | 
55 | The above copyright notice and this permission notice shall be included in
56 | all copies or substantial portions of the Software.
57 | 
58 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
59 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
60 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
61 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
62 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
63 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
64 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
65 | 


--------------------------------------------------------------------------------
/test/coverage.txt:
--------------------------------------------------------------------------------
  1 | 
  2 | # Coverage
  3 | 
  4 | This file is just a collection of tests designed to activate code in MD4C
  5 | which may otherwise be hard to hit. It's to improve our test coverage.
  6 | 
  7 | 
  8 | ## `md_is_unicode_whitespace__()`
  9 | 
 10 | Unicode whitespace (here U+2000) forms a word boundary so these cannot be
 11 | resolved as emphasis span because there is no closer mark.
 12 | 
 13 | ```````````````````````````````` example
 14 | *foo *bar
 15 | .
 16 | <p>*foo *bar</p>
 17 | ````````````````````````````````
 18 | 
 19 | 
 20 | ## `md_is_unicode_punct__()`
 21 | 
 22 | Ditto for Unicode punctuation (here U+00A1).
 23 | 
 24 | ```````````````````````````````` example
 25 | *foo¡*bar
 26 | .
 27 | <p>*foo¡*bar</p>
 28 | ````````````````````````````````
 29 | 
 30 | 
 31 | ## `md_get_unicode_fold_info()`
 32 | 
 33 | ```````````````````````````````` example
 34 | [Příliš žluťoučký kůň úpěl ďábelské ódy.]
 35 | 
 36 | [PŘÍLIŠ ŽLUŤOUČKÝ KŮŇ ÚPĚL ĎÁBELSKÉ ÓDY.]: /url
 37 | .
 38 | <p><a href="/url">Příliš žluťoučký kůň úpěl ďábelské ódy.</a></p>
 39 | ````````````````````````````````
 40 | 
 41 | 
 42 | ## `md_decode_utf8__()` and `md_decode_utf8_before__()`
 43 | 
 44 | ### Alphanumerical Character (i.e. not whitespace, not punctuation)
 45 | 
 46 | Non-whitespace & non-punctuation characters below suppress `_` from being
 47 | recognized as an emphasis because `_` should be seen as in-word character:
 48 | 
 49 | Example of 1-byte UTF-8 sequence (U+0058):
 50 | ```````````````````````````````` example
 51 | X__foo__X
 52 | .
 53 | <p>X__foo__X</p>
 54 | ````````````````````````````````
 55 | 
 56 | Example of 2-byte UTF-8 sequence (U+0158):
 57 | ```````````````````````````````` example
 58 | Ř__foo__Ř
 59 | .
 60 | <p>Ř__foo__Ř</p>
 61 | ````````````````````````````````
 62 | 
 63 | Example of 3-byte UTF-8 sequence (U+0BA3):
 64 | ```````````````````````````````` example
 65 | ண__foo__ண
 66 | .
 67 | <p>ண__foo__ண</p>
 68 | ````````````````````````````````
 69 | 
 70 | Example of 4-byte UTF-8 sequence (U+13142):
 71 | ```````````````````````````````` example
 72 | 𓅂__foo__𓅂
 73 | .
 74 | <p>𓅂__foo__𓅂</p>
 75 | ````````````````````````````````
 76 | 
 77 | ### Whitespace character
 78 | 
 79 | Whitespace on the other hand should not suppress `_`:
 80 | 
 81 | Example of 1-byte UTF-8 sequence (U+0009):
 82 | ```````````````````````````````` example
 83 | x→__foo__→
 84 | .
 85 | <p>x <strong>foo</strong></p>
 86 | ````````````````````````````````
 87 | (The initial `x` to suppress indented code block.)
 88 | 
 89 | Example of 2-byte UTF-8 sequence (U+00A0):
 90 | ```````````````````````````````` example
 91 |  __foo__
 92 | .
 93 | <p> <strong>foo</strong> </p>
 94 | ````````````````````````````````
 95 | 
 96 | Example of 3-byte UTF-8 sequence (U+2000):
 97 | ```````````````````````````````` example
 98 |  __foo__
 99 | .
100 | <p> <strong>foo</strong> </p>
101 | ````````````````````````````````
102 | 
103 | (AFAIK, there is no 4-byte UTF-8 whitespace.)
104 | 
105 | ### Punctuation character
106 | 
107 | Punctuation also should not suppress `_`:
108 | 
109 | Example of 1-byte UTF-8 sequence (U+002E):
110 | ```````````````````````````````` example
111 | .__foo__.
112 | .
113 | <p>.<strong>foo</strong>.</p>
114 | ````````````````````````````````
115 | 
116 | Example of 2-byte UTF-8 sequence (U+00B7):
117 | ```````````````````````````````` example
118 | ·__foo__·
119 | .
120 | <p>·<strong>foo</strong>·</p>
121 | ````````````````````````````````
122 | 
123 | Example of 3-byte UTF-8 sequence (U+0C84):
124 | ```````````````````````````````` example
125 | ಄__foo__಄
126 | .
127 | <p>಄<strong>foo</strong>಄</p>
128 | ````````````````````````````````
129 | 
130 | Example of 4-byte UTF-8 sequence (U+1039F):
131 | ```````````````````````````````` example
132 | 𐎟__foo__𐎟
133 | .
134 | <p>𐎟<strong>foo</strong>𐎟</p>
135 | ````````````````````````````````
136 | 
137 | 
138 | ## `md_is_link_destination_A()`
139 | 
140 | ```````````````````````````````` example
141 | [link](</url\.with\.escape>)
142 | .
143 | <p><a href="/url.with.escape">link</a></p>
144 | ````````````````````````````````
145 | 
146 | 
147 | ## `md_link_label_eq()`
148 | 
149 | ```````````````````````````````` example
150 | [foo bar]
151 | 
152 | [foo bar]: /url
153 | .
154 | <p><a href="/url">foo bar</a></p>
155 | ````````````````````````````````
156 | 
157 | 
158 | ## `md_is_inline_link_spec()`
159 | 
160 | ```````````````````````````````` example
161 | > [link](/url 'foo
162 | > bar')
163 | .
164 | <blockquote>
165 | <p><a href="/url" title="foo
166 | bar">link</a></p>
167 | </blockquote>
168 | ````````````````````````````````
169 | 
170 | 
171 | ## `md_build_ref_def_hashtable()`
172 | 
173 | All link labels in the following example all have the same FNV1a hash (after
174 | normalization of the label, which means after converting to a vector of Unicode
175 | codepoints and lowercase folding).
176 | 
177 | So the example triggers quite complex code paths which are not otherwise easily
178 | tested.
179 | 
180 | ```````````````````````````````` example
181 | [foo]: /foo
182 | [qnptgbh]: /qnptgbh
183 | [abgbrwcv]: /abgbrwcv
184 | [abgbrwcv]: /abgbrwcv2
185 | [abgbrwcv]: /abgbrwcv3
186 | [abgbrwcv]: /abgbrwcv4
187 | [alqadfgn]: /alqadfgn
188 | 
189 | [foo]
190 | [qnptgbh]
191 | [abgbrwcv]
192 | [alqadfgn]
193 | [axgydtdu]
194 | .
195 | <p><a href="/foo">foo</a>
196 | <a href="/qnptgbh">qnptgbh</a>
197 | <a href="/abgbrwcv">abgbrwcv</a>
198 | <a href="/alqadfgn">alqadfgn</a>
199 | [axgydtdu]</p>
200 | ````````````````````````````````
201 | 
202 | For the sake of completeness, the following C program was used to find the hash
203 | collisions by brute force:
204 | 
205 | ~~~
206 | 
207 | #include <stdio.h>
208 | #include <string.h>
209 | 
210 | 
211 | static unsigned etalon;
212 | 
213 | 
214 | 
215 | #define MD_FNV1A_BASE       2166136261
216 | #define MD_FNV1A_PRIME      16777619
217 | 
218 | static inline unsigned
219 | fnv1a(unsigned base, const void* data, size_t n)
220 | {
221 |     const unsigned char* buf = (const unsigned char*) data;
222 |     unsigned hash = base;
223 |     size_t i;
224 | 
225 |     for(i = 0; i < n; i++) {
226 |         hash ^= buf[i];
227 |         hash *= MD_FNV1A_PRIME;
228 |     }
229 | 
230 |     return hash;
231 | }
232 | 
233 | 
234 | static unsigned
235 | unicode_hash(const char* data, size_t n)
236 | {
237 |     unsigned value;
238 |     unsigned hash = MD_FNV1A_BASE;
239 |     int i;
240 | 
241 |     for(i = 0; i < n; i++) {
242 |         value = data[i];
243 |         hash = fnv1a(hash, &value, sizeof(unsigned));
244 |     }
245 | 
246 |     return hash;
247 | }
248 | 
249 | 
250 | static void
251 | recurse(char* buffer, size_t off, size_t len)
252 | {
253 |     int ch;
254 | 
255 |     if(off < len - 1) {
256 |         for(ch = 'a'; ch <= 'z'; ch++) {
257 |             buffer[off] = ch;
258 |             recurse(buffer, off+1, len);
259 |         }
260 |     } else {
261 |         for(ch = 'a'; ch <= 'z'; ch++) {
262 |             buffer[off] = ch;
263 |             if(unicode_hash(buffer, len) == etalon) {
264 |                 printf("Dup: %.*s\n", (int)len, buffer);
265 |             }
266 |         }
267 |     }
268 | }
269 | 
270 | int
271 | main(int argc, char** argv)
272 | {
273 |     char buffer[32];
274 |     int len;
275 | 
276 |     if(argc < 2)
277 |         etalon = unicode_hash("foo", 3);
278 |     else
279 |         etalon = unicode_hash(argv[1], strlen(argv[1]));
280 | 
281 |     for(len = 1; len <= sizeof(buffer); len++)
282 |         recurse(buffer, 0, len);
283 | 
284 |     return 0;
285 | }
286 | ~~~
287 | 
288 | 
289 | ## Flag `MD_FLAG_COLLAPSEWHITESPACE`
290 | 
291 | ```````````````````````````````` example
292 | foo  bar → baz
293 | .
294 | <p>foo bar baz</p>
295 | .
296 | --fcollapse-whitespace
297 | ````````````````````````````````
298 | 


--------------------------------------------------------------------------------
/test/fuzzers/fuzz-mdhtml.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdint.h>
 3 | #include <stdlib.h>
 4 | #include "md4c-html.h"
 5 | 
 6 | 
 7 | static void
 8 | process_output(const MD_CHAR* text, MD_SIZE size, void* userdata)
 9 | {
10 |    /* This is a dummy function because we don't need to generate any output
11 |     * actually. */
12 |    return;
13 | }
14 | 
15 | int
16 | LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
17 | {
18 |     unsigned parser_flags, renderer_flags;
19 | 
20 |     /* We interpret the 1st 8 bytes as parser flags and renderer flags. */
21 |     if(size < 2 * sizeof(unsigned)) {
22 |         return 0;
23 |     }
24 |     parser_flags = ((unsigned*)data)[0];
25 |     renderer_flags = ((unsigned*)data)[1];
26 |     data += 2 * sizeof(unsigned);
27 |     size -= 2 * sizeof(unsigned);
28 | 
29 |     md_html(data, size, process_output, NULL, parser_flags, renderer_flags);
30 |     return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/test/fuzzers/seed-corpus/commonmark.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # h1
 3 | ## h2
 4 | ### h3
 5 | #### h4
 6 | ##### h5
 7 | ###### h6
 8 | 
 9 | h1
10 | ==
11 | 
12 | h2
13 | --
14 | 
15 | --------------------
16 | 
17 |     indented code
18 | 
19 | ```
20 | fenced code
21 | ```
22 | 
23 | <tag attr='val' attr2="val2">
24 | 
25 | > quote
26 | 
27 | * list item
28 | 1. list item
29 | 
30 | [ref]: /url
31 | 
32 | paragraph
33 | &copy; &#1234; &#xabcd;
34 | `code`
35 | *emph* **strong** ***strong emph***
36 | _emph_ __strong__ ___strong emph___
37 | [ref] [ref][] [link](/url)
38 | ![ref] ![ref][] ![img](/url)
39 | <http://example.com> <doe@example.com>
40 | \\ \* \. \` \
41 | 


--------------------------------------------------------------------------------
/test/fuzzers/seed-corpus/gfm.md:
--------------------------------------------------------------------------------
 1 | * [ ] unchecked
 2 | * [x] checked
 3 | 
 4 |  A | B | C
 5 | ---|--:|:-:
 6 | aaa|bbb|ccc
 7 | 
 8 | ~del~ ~~del~~
 9 | 
10 | http://example.com www.example.com doe@example.com
11 | 


--------------------------------------------------------------------------------
/test/fuzzers/seed-corpus/latex-math.md:
--------------------------------------------------------------------------------
1 | $a^2+b^2=c^2$ $$a^2+b^2=c^2$$
2 | 


--------------------------------------------------------------------------------
/test/fuzzers/seed-corpus/wiki.md:
--------------------------------------------------------------------------------
1 | [[wiki]] [[wiki|label]]
2 | 


--------------------------------------------------------------------------------
/test/normalize.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | from html.parser import HTMLParser
  3 | import urllib
  4 | 
  5 | try:
  6 |     from html.parser import HTMLParseError
  7 | except ImportError:
  8 |     # HTMLParseError was removed in Python 3.5. It could never be
  9 |     # thrown, so we define a placeholder instead.
 10 |     class HTMLParseError(Exception):
 11 |         pass
 12 | 
 13 | from html.entities import name2codepoint
 14 | import sys
 15 | import re
 16 | import html
 17 | 
 18 | # Normalization code, adapted from
 19 | # https://github.com/karlcow/markdown-testsuite/
 20 | significant_attrs = ["alt", "href", "src", "title"]
 21 | whitespace_re = re.compile('\s+')
 22 | class MyHTMLParser(HTMLParser):
 23 |     def __init__(self):
 24 |         HTMLParser.__init__(self)
 25 |         self.convert_charrefs = False
 26 |         self.last = "starttag"
 27 |         self.in_pre = False
 28 |         self.output = ""
 29 |         self.last_tag = ""
 30 |     def handle_data(self, data):
 31 |         after_tag = self.last == "endtag" or self.last == "starttag"
 32 |         after_block_tag = after_tag and self.is_block_tag(self.last_tag)
 33 |         if after_tag and self.last_tag == "br":
 34 |             data = data.lstrip('\n')
 35 |         if not self.in_pre:
 36 |             data = whitespace_re.sub(' ', data)
 37 |         if after_block_tag and not self.in_pre:
 38 |             if self.last == "starttag":
 39 |                 data = data.lstrip()
 40 |             elif self.last == "endtag":
 41 |                 data = data.strip()
 42 |         self.output += data
 43 |         self.last = "data"
 44 |     def handle_endtag(self, tag):
 45 |         if tag == "pre":
 46 |             self.in_pre = False
 47 |         elif self.is_block_tag(tag):
 48 |             self.output = self.output.rstrip()
 49 |         self.output += "</" + tag + ">"
 50 |         self.last_tag = tag
 51 |         self.last = "endtag"
 52 |     def handle_starttag(self, tag, attrs):
 53 |         if tag == "pre":
 54 |             self.in_pre = True
 55 |         if self.is_block_tag(tag):
 56 |             self.output = self.output.rstrip()
 57 |         self.output += "<" + tag
 58 |         # For now we don't strip out 'extra' attributes, because of
 59 |         # raw HTML test cases.
 60 |         # attrs = filter(lambda attr: attr[0] in significant_attrs, attrs)
 61 |         if attrs:
 62 |             attrs.sort()
 63 |             for (k,v) in attrs:
 64 |                 self.output += " " + k
 65 |                 if v in ['href','src']:
 66 |                     self.output += ("=" + '"' +
 67 |                             urllib.quote(urllib.unquote(v), safe='/') + '"')
 68 |                 elif v != None:
 69 |                     self.output += ("=" + '"' + html.escape(v,quote=True) + '"')
 70 |         self.output += ">"
 71 |         self.last_tag = tag
 72 |         self.last = "starttag"
 73 |     def handle_startendtag(self, tag, attrs):
 74 |         """Ignore closing tag for self-closing """
 75 |         self.handle_starttag(tag, attrs)
 76 |         self.last_tag = tag
 77 |         self.last = "endtag"
 78 |     def handle_comment(self, data):
 79 |         self.output += '<!--' + data + '-->'
 80 |         self.last = "comment"
 81 |     def handle_decl(self, data):
 82 |         self.output += '<!' + data + '>'
 83 |         self.last = "decl"
 84 |     def unknown_decl(self, data):
 85 |         self.output += '<!' + data + '>'
 86 |         self.last = "decl"
 87 |     def handle_pi(self,data):
 88 |         self.output += '<?' + data + '>'
 89 |         self.last = "pi"
 90 |     def handle_entityref(self, name):
 91 |         try:
 92 |             c = chr(name2codepoint[name])
 93 |         except KeyError:
 94 |             c = None
 95 |         self.output_char(c, '&' + name + ';')
 96 |         self.last = "ref"
 97 |     def handle_charref(self, name):
 98 |         try:
 99 |             if name.startswith("x"):
100 |                 c = chr(int(name[1:], 16))
101 |             else:
102 |                 c = chr(int(name))
103 |         except ValueError:
104 |                 c = None
105 |         self.output_char(c, '&' + name + ';')
106 |         self.last = "ref"
107 |     # Helpers.
108 |     def output_char(self, c, fallback):
109 |         if c == '<':
110 |             self.output += "&lt;"
111 |         elif c == '>':
112 |             self.output += "&gt;"
113 |         elif c == '&':
114 |             self.output += "&amp;"
115 |         elif c == '"':
116 |             self.output += "&quot;"
117 |         elif c == None:
118 |             self.output += fallback
119 |         else:
120 |             self.output += c
121 | 
122 |     def is_block_tag(self,tag):
123 |         return (tag in ['article', 'header', 'aside', 'hgroup', 'blockquote',
124 |             'hr', 'iframe', 'body', 'li', 'map', 'button', 'object', 'canvas',
125 |             'ol', 'caption', 'output', 'col', 'p', 'colgroup', 'pre', 'dd',
126 |             'progress', 'div', 'section', 'dl', 'table', 'td', 'dt',
127 |             'tbody', 'embed', 'textarea', 'fieldset', 'tfoot', 'figcaption',
128 |             'th', 'figure', 'thead', 'footer', 'tr', 'form', 'ul',
129 |             'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'video', 'script', 'style'])
130 | 
131 | def normalize_html(html):
132 |     r"""
133 |     Return normalized form of HTML which ignores insignificant output
134 |     differences:
135 | 
136 |     Multiple inner whitespaces are collapsed to a single space (except
137 |     in pre tags):
138 | 
139 |         >>> normalize_html("<p>a  \t b</p>")
140 |         '<p>a b</p>'
141 | 
142 |         >>> normalize_html("<p>a  \t\nb</p>")
143 |         '<p>a b</p>'
144 | 
145 |     * Whitespace surrounding block-level tags is removed.
146 | 
147 |         >>> normalize_html("<p>a  b</p>")
148 |         '<p>a b</p>'
149 | 
150 |         >>> normalize_html(" <p>a  b</p>")
151 |         '<p>a b</p>'
152 | 
153 |         >>> normalize_html("<p>a  b</p> ")
154 |         '<p>a b</p>'
155 | 
156 |         >>> normalize_html("\n\t<p>\n\t\ta  b\t\t</p>\n\t")
157 |         '<p>a b</p>'
158 | 
159 |         >>> normalize_html("<i>a  b</i> ")
160 |         '<i>a b</i> '
161 | 
162 |     * Self-closing tags are converted to open tags.
163 | 
164 |         >>> normalize_html("<br />")
165 |         '<br>'
166 | 
167 |     * Attributes are sorted and lowercased.
168 | 
169 |         >>> normalize_html('<a title="bar" HREF="foo">x</a>')
170 |         '<a href="foo" title="bar">x</a>'
171 | 
172 |     * References are converted to unicode, except that '<', '>', '&', and
173 |       '"' are rendered using entities.
174 | 
175 |         >>> normalize_html("&forall;&amp;&gt;&lt;&quot;")
176 |         '\u2200&amp;&gt;&lt;&quot;'
177 | 
178 |     """
179 |     html_chunk_re = re.compile("(\<!\[CDATA\[.*?\]\]\>|\<[^>]*\>|[^<]+)")
180 |     try:
181 |         parser = MyHTMLParser()
182 |         # We work around HTMLParser's limitations parsing CDATA
183 |         # by breaking the input into chunks and passing CDATA chunks
184 |         # through verbatim.
185 |         for chunk in re.finditer(html_chunk_re, html):
186 |             if chunk.group(0)[:8] == "<![CDATA":
187 |                 parser.output += chunk.group(0)
188 |             else:
189 |                 parser.feed(chunk.group(0))
190 |         parser.close()
191 |         return parser.output
192 |     except HTMLParseError as e:
193 |         sys.stderr.write("Normalization error: " + e.msg + "\n")
194 |         return html  # on error, return unnormalized HTML
195 | 


--------------------------------------------------------------------------------
/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 | from prog import Prog
  9 | from timeit import default_timer as timer
 10 | 
 11 | if __name__ == "__main__":
 12 |     parser = argparse.ArgumentParser(description='Run Markdown tests.')
 13 |     parser.add_argument('-p', '--program', dest='program', nargs='?', default=None,
 14 |             help='program to test')
 15 |     args = parser.parse_args(sys.argv[1:])
 16 | 
 17 | # list of pairs consisting of input and a regex that must match the output.
 18 | pathological = {
 19 |     # note - some pythons have limit of 65535 for {num-matches} in re.
 20 |     "U+0000":
 21 |             ("abc\u0000de\u0000",
 22 |             re.compile("abc\ufffd?de\ufffd?")),
 23 |     "U+FEFF (Unicode BOM)":
 24 |             ("\ufefffoo",
 25 |             re.compile("<p>foo</p>")),
 26 |     "nested strong emph":
 27 |             (("*a **a " * 65000) + "b" + (" a** a*" * 65000),
 28 |             re.compile("(<em>a <strong>a ){65000}b( a</strong> a</em>){65000}")),
 29 |     "many emph closers with no openers":
 30 |             (("a_ " * 65000),
 31 |             re.compile("(a[_] ){64999}a_")),
 32 |     "many emph openers with no closers":
 33 |             (("_a " * 65000),
 34 |             re.compile("(_a ){64999}_a")),
 35 |     "many 3-emph openers with no closers":
 36 |             (("a***" * 65000),
 37 |             re.compile("(a<em><strong>a</strong></em>){32500}")),
 38 |     "many link closers with no openers":
 39 |             (("a]" * 65000),
 40 |             re.compile("(a\]){65000}")),
 41 |     "many link openers with no closers":
 42 |             (("[a" * 65000),
 43 |             re.compile("(\[a){65000}")),
 44 |     "mismatched openers and closers":
 45 |             (("*a_ " * 50000),
 46 |             re.compile("([*]a[_] ){49999}[*]a_")),
 47 |     "openers and closers multiple of 3":
 48 |             (("a**b" + ("c* " * 50000)),
 49 |             re.compile("a[*][*]b(c[*] ){49999}c[*]")),
 50 |     "link openers and emph closers":
 51 |             (("[ a_" * 50000),
 52 |             re.compile("(\[ a_){50000}")),
 53 |     "hard link/emph case":
 54 |             ("**x [a*b**c*](d)",
 55 |             re.compile("\\*\\*x <a href=\"d\">a<em>b\\*\\*c</em></a>")),
 56 |     "nested brackets":
 57 |             (("[" * 50000) + "a" + ("]" * 50000),
 58 |             re.compile("\[{50000}a\]{50000}")),
 59 |     "nested block quotes":
 60 |             ((("> " * 50000) + "a"),
 61 |             re.compile("(<blockquote>\r?\n){50000}")),
 62 |     "backticks":
 63 |             ("".join(map(lambda x: ("e" + "`" * x), range(1,1000))),
 64 |             re.compile("^<p>[e`]*</p>\r?\n$")),
 65 |     "many links":
 66 |             ("[t](/u) " * 50000,
 67 |             re.compile("(<a href=\"/u\">t</a> ?){50000}")),
 68 |     "many references":
 69 |             ("".join(map(lambda x: ("[" + str(x) + "]: u\n"), range(1,20000 * 16))) + "[0] " * 20000,
 70 |             re.compile("(\[0\] ){19999}")),
 71 |     "deeply nested lists":
 72 |             ("".join(map(lambda x: ("  " * x + "* a\n"), range(0,1000))),
 73 |             re.compile("<ul>\r?\n(<li>a<ul>\r?\n){999}<li>a</li>\r?\n</ul>\r?\n(</li>\r?\n</ul>\r?\n){999}")),
 74 |     "many html openers and closers":
 75 |             (("<>" * 50000),
 76 |             re.compile("(&lt;&gt;){50000}")),
 77 |     "many html proc. inst. openers":
 78 |             (("x" + "<?" * 50000),
 79 |             re.compile("x(&lt;\\?){50000}")),
 80 |     "many html CDATA openers":
 81 |             (("x" + "<![CDATA[" * 50000),
 82 |             re.compile("x(&lt;!\\[CDATA\\[){50000}")),
 83 |     "many backticks and escapes":
 84 |             (("\\``" * 50000),
 85 |             re.compile("(``){50000}")),
 86 |     "many broken link titles":
 87 |             (("[ (](" * 50000),
 88 |             re.compile("(\[ \(\]\(){50000}")),
 89 |     "broken thematic break":
 90 |             (("* " * 50000 + "a"),
 91 |             re.compile("<ul>\r?\n(<li><ul>\r?\n){49999}<li>a</li>\r?\n</ul>\r?\n(</li>\r?\n</ul>\r?\n){49999}")),
 92 |     "nested invalid link references":
 93 |             (("[" * 50000 + "]" * 50000 + "\n\n[a]: /b"),
 94 |             re.compile("\[{50000}\]{50000}")),
 95 |     "many broken permissive autolinks":
 96 |             (("www._" * 50000 + "x"),
 97 |             re.compile("<p>(www._){50000}x</p>"),
 98 |             "--fpermissive-www-autolinks"),
 99 |     "huge table":
100 |             (("th|" * 10000 + "\n" + "-|" * 10000 + "\n" + "td\n" * 10000),
101 |             re.compile(""),
102 |             "--ftables"),
103 |     "many broken links":
104 |             (("]([\n" * 50000),
105 |             re.compile("<p>(\]\(\[\r?\n){49999}\]\(\[</p>")),
106 |     "many link ref. def. instantiations":
107 |             (("[x]: " + "x" * 50000 + "\n[x]" * 50000),
108 |             re.compile(""))
109 | }
110 | 
111 | whitespace_re = re.compile('/s+/')
112 | passed = 0
113 | errored = 0
114 | failed = 0
115 | 
116 | #print("Testing pathological cases:")
117 | for description in pathological:
118 |     if len(pathological[description]) == 2:
119 |         (inp, regex) = pathological[description]
120 |         prog = Prog(cmdline=args.program)
121 |     else:
122 |         (inp, regex, default_options) = pathological[description]
123 |         prog = Prog(cmdline=args.program, default_options=default_options)
124 | 
125 |     start = timer()
126 |     [rc, actual, err] = prog.to_html(inp)
127 |     end = timer()
128 |     if rc != 0:
129 |         errored += 1
130 |         print('{:35} [ERRORED (exit code {})]'.format(description, rc))
131 |         print(err)
132 |     elif regex.search(actual):
133 |         print('{:35} [PASSED] {:.3f} secs'.format(description, end-start))
134 |         passed += 1
135 |     else:
136 |         print('{:35} [FAILED]'.format(description))
137 |         print(repr(actual))
138 |         failed += 1
139 | 
140 | print("%d passed, %d failed, %d errored" % (passed, failed, errored))
141 | if (failed == 0 and errored == 0):
142 |     exit(0)
143 | else:
144 |     exit(1)
145 | 


--------------------------------------------------------------------------------
/test/prog.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | # -*- coding: utf-8 -*-
 3 | 
 4 | from subprocess import *
 5 | import platform
 6 | import os
 7 | 
 8 | def pipe_through_prog(argv, text):
 9 |     p1 = Popen(argv, stdout=PIPE, stdin=PIPE, stderr=PIPE)
10 |     [result, err] = p1.communicate(input=text.encode('utf-8'))
11 |     return [p1.returncode, result.decode('utf-8'), err]
12 | 
13 | class Prog:
14 |     def __init__(self, cmdline="md2html", default_options=[]):
15 |         self.cmdline = cmdline.split()
16 |         if len(self.cmdline) <= 1:
17 |             # cmdline provided no command line options. Use default ones.
18 |             if isinstance(default_options, str):
19 |                 self.cmdline += default_options.split()
20 |             else:
21 |                 self.cmdline += default_options
22 |         self.to_html = lambda x: pipe_through_prog(self.cmdline, x)
23 | 


--------------------------------------------------------------------------------
/test/regressions.txt:
--------------------------------------------------------------------------------
  1 | 
  2 | # Regressions
  3 | 
  4 | These are (mostly) unit tests collected via bug resolving. Adding them here
  5 | prevents us from reintroducing subtle bugs which we've already seen.
  6 | 
  7 | 
  8 | ## [Issue 2](https://github.com/mity/md4c/issues/2)
  9 | 
 10 | Raw HTML block:
 11 | 
 12 | ```````````````````````````````` example
 13 | <gi att1=tok1 att2=tok2>
 14 | .
 15 | <gi att1=tok1 att2=tok2>
 16 | ````````````````````````````````
 17 | 
 18 | Inline:
 19 | 
 20 | ```````````````````````````````` example
 21 | foo <gi att1=tok1 att2=tok2> bar
 22 | .
 23 | <p>foo <gi att1=tok1 att2=tok2> bar</p>
 24 | ````````````````````````````````
 25 | 
 26 | Inline with a line break:
 27 | 
 28 | ```````````````````````````````` example
 29 | foo <gi att1=tok1
 30 | att2=tok2> bar
 31 | .
 32 | <p>foo <gi att1=tok1
 33 | att2=tok2> bar</p>
 34 | ````````````````````````````````
 35 | 
 36 | 
 37 | ## [Issue 4](https://github.com/mity/md4c/issues/4)
 38 | 
 39 | ```````````````````````````````` example
 40 | ![alt text with *entity* &copy;](img.png 'title')
 41 | .
 42 | <p><img src="img.png" alt="alt text with entity ©" title="title"></p>
 43 | ````````````````````````````````
 44 | 
 45 | 
 46 | ## [Issue 9](https://github.com/mity/md4c/issues/9)
 47 | 
 48 | ```````````````````````````````` example
 49 | > [foo
 50 | > bar]: /url
 51 | >
 52 | > [foo bar]
 53 | .
 54 | <blockquote>
 55 | <p><a href="/url">foo
 56 | bar</a></p>
 57 | </blockquote>
 58 | ````````````````````````````````
 59 | 
 60 | 
 61 | ## [Issue 10](https://github.com/mity/md4c/issues/10)
 62 | 
 63 | ```````````````````````````````` example
 64 | [x]:
 65 | x
 66 | - <?
 67 | 
 68 |   x
 69 | .
 70 | <ul>
 71 | <li><?
 72 | 
 73 | x
 74 | </li>
 75 | </ul>
 76 | ````````````````````````````````
 77 | 
 78 | 
 79 | ## [Issue 11](https://github.com/mity/md4c/issues/11)
 80 | 
 81 | ```````````````````````````````` example
 82 | x [link](/url "foo &ndash; bar") x
 83 | .
 84 | <p>x <a href="/url" title="foo – bar">link</a> x</p>
 85 | ````````````````````````````````
 86 | 
 87 | 
 88 | ## [Issue 14](https://github.com/mity/md4c/issues/14)
 89 | 
 90 | ```````````````````````````````` example
 91 | a***b* c*
 92 | .
 93 | <p>a*<em><em>b</em> c</em></p>
 94 | ````````````````````````````````
 95 | 
 96 | 
 97 | ## [Issue 15](https://github.com/mity/md4c/issues/15)
 98 | 
 99 | ```````````````````````````````` example
100 | ***b* c*
101 | .
102 | <p>*<em><em>b</em> c</em></p>
103 | ````````````````````````````````
104 | 
105 | 
106 | ## [Issue 21](https://github.com/mity/md4c/issues/21)
107 | 
108 | ```````````````````````````````` example
109 | a*b**c*
110 | .
111 | <p>a<em>b**c</em></p>
112 | ````````````````````````````````
113 | 
114 | 
115 | ## [Issue 33](https://github.com/mity/md4c/issues/33)
116 | 
117 | ```````````````````````````````` example
118 | ```&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;
119 | .
120 | <pre><code class="language-&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;"></code></pre>
121 | ````````````````````````````````
122 | 
123 | 
124 | ## [Issue 36](https://github.com/mity/md4c/issues/36)
125 | 
126 | ```````````````````````````````` example
127 | __x_ _x___
128 | .
129 | <p><em><em>x</em> <em>x</em></em>_</p>
130 | ````````````````````````````````
131 | 
132 | 
133 | ## [Issue 39](https://github.com/mity/md4c/issues/39)
134 | 
135 | ```````````````````````````````` example
136 | [\\]: x
137 | .
138 | ````````````````````````````````
139 | 
140 | 
141 | ## [Issue 40](https://github.com/mity/md4c/issues/40)
142 | 
143 | ```````````````````````````````` example
144 | [x](url
145 | 'title'
146 | )x
147 | .
148 | <p><a href="url" title="title">x</a>x</p>
149 | ````````````````````````````````
150 | 
151 | 
152 | ## [Issue 41](https://github.com/mity/md4c/issues/41)
153 | ```````````````````````````````` example
154 | * x|x
155 | ---|---
156 | .
157 | <ul>
158 | <li>x|x
159 | ---|---</li>
160 | </ul>
161 | .
162 | --ftables
163 | ````````````````````````````````
164 | (Not a table, because the underline has wrong indentation and is not part of the
165 | list item.)
166 | 
167 | ```````````````````````````````` example
168 | * x|x
169 |   ---|---
170 | x|x
171 | .
172 | <ul>
173 | <li><table>
174 | <thead>
175 | <tr>
176 | <th>x</th>
177 | <th>x</th>
178 | </tr>
179 | </thead>
180 | </table>
181 | </li>
182 | </ul>
183 | <p>x|x</p>
184 | .
185 | --ftables
186 | ````````````````````````````````
187 | (Here the underline has the right indentation so the table is detected.
188 | But the last line is not part of it due its indentation.)
189 | 
190 | 
191 | ## [Issue 42](https://github.com/mity/md4c/issues/42)
192 | 
193 | ```````````````````````````````` example
194 | ] http://x.x *x*
195 | 
196 | |x|x|
197 | |---|---|
198 | |x|
199 | .
200 | <p>] http://x.x <em>x</em></p>
201 | <table>
202 | <thead>
203 | <tr>
204 | <th>x</th>
205 | <th>x</th>
206 | </tr>
207 | </thead>
208 | <tbody>
209 | <tr>
210 | <td>x</td>
211 | <td></td>
212 | </tr>
213 | </tbody>
214 | </table>
215 | .
216 | --ftables
217 | ````````````````````````````````
218 | 
219 | 
220 | ## [Issue 53](https://github.com/mity/md4c/issues/53)
221 | 
222 | ```````````````````````````````` example
223 | This is [link](http://github.com/).
224 | .
225 | <p>This is <a href="http://github.com/">link</a>.</p>
226 | .
227 | --fpermissive-url-autolinks
228 | ````````````````````````````````
229 | 
230 | ```````````````````````````````` example
231 | This is [link](http://github.com/)X
232 | .
233 | <p>This is <a href="http://github.com/">link</a>X</p>
234 | .
235 | --fpermissive-url-autolinks
236 | ````````````````````````````````
237 | 
238 | 
239 | ## [Issue 65](https://github.com/mity/md4c/issues/65)
240 | 
241 | ```````````````````````````````` example
242 | `
243 | .
244 | <p>`</p>
245 | ````````````````````````````````
246 | 
247 | 
248 | ## [Issue 69](https://github.com/mity/md4c/issues/69)
249 | ```````````````````````````````` example
250 | ~`foo`~
251 | .
252 | <p><del><code>foo</code></del></p>
253 | .
254 | --fstrikethrough
255 | ````````````````````````````````
256 | 
257 | ```````````````````````````````` example
258 | ~*foo*~
259 | .
260 | <p><del><em>foo</em></del></p>
261 | .
262 | --fstrikethrough
263 | ````````````````````````````````
264 | 
265 | ```````````````````````````````` example
266 | *~foo~*
267 | .
268 | <p><em><del>foo</del></em></p>
269 | .
270 | --fstrikethrough
271 | ````````````````````````````````
272 | 
273 | 
274 | ## [Issue 74](https://github.com/mity/md4c/issues/74)
275 | 
276 | ```````````````````````````````` example
277 | [f]:
278 | -
279 |     xx
280 | -
281 | .
282 | <pre><code>xx
283 | </code></pre>
284 | <ul>
285 | <li></li>
286 | </ul>
287 | ````````````````````````````````
288 | 
289 | 
290 | ## [Issue 76](https://github.com/mity/md4c/issues/76)
291 | 
292 | ```````````````````````````````` example
293 | *(http://example.com)*
294 | .
295 | <p><em>(<a href="http://example.com">http://example.com</a>)</em></p>
296 | .
297 | --fpermissive-url-autolinks
298 | ````````````````````````````````
299 | 
300 | 
301 | ## [Issue 78](https://github.com/mity/md4c/issues/78)
302 | 
303 | ```````````````````````````````` example
304 | [SS ẞ]: /url
305 | [ẞ SS]
306 | .
307 | <p><a href="/url">ẞ SS</a></p>
308 | ````````````````````````````````
309 | 
310 | 
311 | ## [Issue 83](https://github.com/mity/md4c/issues/83)
312 | 
313 | ```````````````````````````````` example
314 | foo
315 | >
316 | .
317 | <p>foo</p>
318 | <blockquote>
319 | </blockquote>
320 | 
321 | ````````````````````````````````
322 | 
323 | 
324 | ## [Issue 95](https://github.com/mity/md4c/issues/95)
325 | 
326 | ```````````````````````````````` example
327 | . foo
328 | .
329 | <p>. foo</p>
330 | ````````````````````````````````
331 | 
332 | 
333 | ## [Issue 96](https://github.com/mity/md4c/issues/96)
334 | 
335 | ```````````````````````````````` example
336 | [ab]: /foo
337 | [a] [ab] [abc]
338 | .
339 | <p>[a] <a href="/foo">ab</a> [abc]</p>
340 | ````````````````````````````````
341 | 
342 | ```````````````````````````````` example
343 | [a b]: /foo
344 | [a   b]
345 | .
346 | <p><a href="/foo">a   b</a></p>
347 | ````````````````````````````````
348 | 
349 | 
350 | ## [Issue 97](https://github.com/mity/md4c/issues/97)
351 | 
352 | ```````````````````````````````` example
353 | *a **b c* d**
354 | .
355 | <p><em>a <em><em>b c</em> d</em></em></p>
356 | 
357 | ````````````````````````````````
358 | 
359 | 
360 | ## [Issue 100](https://github.com/mity/md4c/issues/100)
361 | 
362 | ```````````````````````````````` example
363 | <foo@123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123>
364 | .
365 | <p><a href="mailto:foo@123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123">foo@123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123</a></p>
366 | ````````````````````````````````
367 | 
368 | ```````````````````````````````` example
369 | <foo@123456789012345678901234567890123456789012345678901234567890123x.123456789012345678901234567890123456789012345678901234567890123>
370 | .
371 | <p>&lt;foo@123456789012345678901234567890123456789012345678901234567890123x.123456789012345678901234567890123456789012345678901234567890123&gt;</p>
372 | ````````````````````````````````
373 | (Note the `x` here which turns it over the max. allowed length limit.)
374 | 
375 | 
376 | ## [Issue 104](https://github.com/mity/md4c/issues/104)
377 | 
378 | ```````````````````````````````` example
379 | A | B
380 | --- | ---
381 | [x](url)
382 | .
383 | <table>
384 | <thead>
385 | <tr>
386 | <th>A</th>
387 | <th>B</th>
388 | </tr>
389 | </thead>
390 | <tbody>
391 | <tr>
392 | <td><a href="url">x</a></td>
393 | <td></td>
394 | </tr>
395 | </tbody>
396 | </table>
397 | .
398 | --ftables
399 | ````````````````````````````````
400 | 
401 | 
402 | ## [Issue 107](https://github.com/mity/md4c/issues/107)
403 | 
404 | ```````````````````````````````` example
405 | ***foo *bar baz***
406 | .
407 | <p>*<strong>foo <em>bar baz</em></strong></p>
408 | 
409 | ````````````````````````````````
410 | 
411 | 
412 | ## [Issue 124](https://github.com/mity/md4c/issues/124)
413 | 
414 | ```````````````````````````````` example
415 | ~~~
416 |                 x
417 | ~~~
418 | 
419 | ~~~
420 |                  x
421 | ~~~
422 | .
423 | <pre><code>                x
424 | </code></pre>
425 | <pre><code>                 x
426 | </code></pre>
427 | ````````````````````````````````
428 | 
429 | 
430 | ## [Issue 131](https://github.com/mity/md4c/issues/131)
431 | 
432 | ```````````````````````````````` example
433 | [![alt][img]][link]
434 | 
435 | [img]: img_url
436 | [link]: link_url
437 | .
438 | <p><a href="link_url"><img src="img_url" alt="alt"></a></p>
439 | ````````````````````````````````
440 | 
441 | 
442 | ## [Issue 138](https://github.com/mity/md4c/issues/138)
443 | 
444 | ```````````````````````````````` example
445 | | abc | def |
446 | | --- | --- |
447 | .
448 | <table>
449 | <thead>
450 | <tr>
451 | <th>abc</th>
452 | <th>def</th>
453 | </tr>
454 | </thead>
455 | </table>
456 | .
457 | --ftables
458 | ````````````````````````````````
459 | 
460 | 
461 | ## [Issue 142](https://github.com/mity/md4c/issues/142)
462 | 
463 | ```````````````````````````````` example
464 | [fooﬗ]: /url
465 | [fooﬕ]
466 | .
467 | <p>[fooﬕ]</p>
468 | ````````````````````````````````
469 | 
470 | 
471 | ## [Issue 149](https://github.com/mity/md4c/issues/149)
472 | 
473 | ```````````````````````````````` example
474 | - <script>
475 | - foo
476 | bar
477 | </script>
478 | .
479 | <ul>
480 | <li><script>
481 | </li>
482 | <li>foo
483 | bar
484 | </script></li>
485 | </ul>
486 | ````````````````````````````````
487 | 
488 | 
489 | ## [Issue 152](https://github.com/mity/md4c/issues/152)
490 | 
491 | ```````````````````````````````` example
492 | [http://example.com](http://example.com)
493 | .
494 | <p><a href="http://example.com">http://example.com</a></p>
495 | .
496 | --fpermissive-url-autolinks
497 | ````````````````````````````````
498 | 
499 | 
500 | ## [Issue 190](https://github.com/mity/md4c/issues/190)
501 | 
502 | ```````````````````````````````` example
503 | -
504 | 
505 |     foo
506 | .
507 | <ul>
508 | <li></li>
509 | </ul>
510 | <pre><code>foo
511 | </code></pre>
512 | ````````````````````````````````
513 | 
514 | 
515 | ## [Issue 200](https://github.com/mity/md4c/issues/200)
516 | 
517 | ```````````````````````````````` example
518 | <!-- foo -->
519 |     ```
520 |     bar
521 |     ```
522 | .
523 | <!-- foo -->
524 | <pre><code>```
525 | bar
526 | ```
527 | </code></pre>
528 | ````````````````````````````````
529 | 
530 | 
531 | ## [Issue 201](https://github.com/mity/md4c/issues/201)
532 | 
533 | ```````````````````````````````` example
534 | foo
535 |     ```
536 |     bar
537 |     ```
538 | .
539 | <p>foo
540 | <code>bar</code></p>
541 | ````````````````````````````````
542 | 
543 | 
544 | ## [Issue 207](https://github.com/mity/md4c/issues/207)
545 | 
546 | ```````````````````````````````` example
547 | <textarea>
548 | 
549 | *foo*
550 | 
551 | _bar_
552 | 
553 | </textarea>
554 | 
555 | baz
556 | .
557 | <textarea>
558 | 
559 | *foo*
560 | 
561 | _bar_
562 | 
563 | </textarea>
564 | <p>baz</p>
565 | ````````````````````````````````
566 | 
567 | 
568 | ## [Issue 210](https://github.com/mity/md4c/issues/210)
569 | 
570 | ```````````````````````````````` example
571 | ![outer ![inner](img_inner "inner title")](img_outer "outer title")
572 | .
573 | <p><img src="img_outer" alt="outer inner" title="outer title"></p>
574 | ````````````````````````````````
575 | 
576 | 
577 | ## [Issue 212](https://github.com/mity/md4c/issues/212)
578 | 
579 | ```````````````````````````````` example
580 | x
581 | |-
582 | |[*x*]()
583 | .
584 | <table>
585 | <thead>
586 | <tr>
587 | <th>x</th>
588 | </tr>
589 | </thead>
590 | <tbody>
591 | <tr>
592 | <td><a href=""><em>x</em></a></td>
593 | </tr>
594 | </tbody>
595 | </table>
596 | .
597 | --ftables
598 | ````````````````````````````````
599 | 
600 | 
601 | ## [Issue 213](https://github.com/mity/md4c/issues/215)
602 | 
603 | ```````````````````````````````` example
604 | x
605 | |-
606 | [|
607 | 
608 | [[ ]][[![|]()]]
609 | .
610 | <table>
611 | <thead>
612 | <tr>
613 | <th>x</th>
614 | </tr>
615 | </thead>
616 | <tbody>
617 | <tr>
618 | <td>[</td>
619 | </tr>
620 | </tbody>
621 | </table>
622 | <p><x-wikilink data-target=" "> </x-wikilink><x-wikilink data-target="![|]()"><img src="" alt="|"></x-wikilink></p>
623 | .
624 | --ftables --fwiki-links
625 | ````````````````````````````````
626 | 
627 | 
628 | ## [Issue 215](https://github.com/mity/md4c/issues/215)
629 | 
630 | ```````````````````````````````` example
631 | title
632 | --→
633 | .
634 | <h2>title</h2>
635 | ````````````````````````````````
636 | 
637 | 
638 | ## [Issue 216](https://github.com/mity/md4c/issues/216)
639 | 
640 | ```````````````````````````````` example
641 | x <!A>
642 | .
643 | <p>x <!A></p>
644 | ````````````````````````````````
645 | 
646 | 
647 | ## [Issue 217](https://github.com/mity/md4c/issues/217)
648 | 
649 | ```````````````````````````````` example
650 | __!_!__
651 | 
652 | __!x!__
653 | 
654 | **!*!**
655 | 
656 | ---
657 | 
658 | _*__*_*
659 | 
660 | _*xx*_*
661 | 
662 | _*__-_-
663 | 
664 | _*xx-_-
665 | .
666 | <p><strong>!_!</strong></p>
667 | <p><strong>!x!</strong></p>
668 | <p><strong>!*!</strong></p>
669 | <hr />
670 | <p><em><em>__</em></em>*</p>
671 | <p><em><em>xx</em></em>*</p>
672 | <p><em>*__-</em>-</p>
673 | <p><em>*xx-</em>-</p>
674 | ````````````````````````````````
675 | 
676 | 
677 | ## [Issue 222](https://github.com/mity/md4c/issues/222)
678 | 
679 | ```````````````````````````````` example
680 | ~foo ~bar baz~
681 | .
682 | <p>~foo <del>bar baz</del></p>
683 | .
684 | --fstrikethrough
685 | ````````````````````````````````
686 | 
687 | 
688 | ## [Issue 223](https://github.com/mity/md4c/issues/223)
689 | 
690 | If from one side (and the other has no space/newline), replace new line with
691 | space.
692 | 
693 | ```````````````````````````````` example [no-normalize]
694 | `
695 | foo`
696 | .
697 | <p><code> foo</code></p>
698 | ````````````````````````````````
699 | 
700 | ```````````````````````````````` example [no-normalize]
701 | `foo
702 | `
703 | .
704 | <p><code>foo </code></p>
705 | ````````````````````````````````
706 | 
707 | If from both side, eat it.
708 | 
709 | ```````````````````````````````` example [no-normalize]
710 | `
711 | foo
712 | `
713 | .
714 | <p><code>foo</code></p>
715 | ````````````````````````````````
716 | 
717 | 
718 | ## [Issue 226](https://github.com/mity/md4c/issues/226)
719 | 
720 | ```````````````````````````````` example
721 | https://example.com/
722 | https://example.com/dir/
723 | .
724 | <p><a href="https://example.com/">https://example.com/</a>
725 | <a href="https://example.com/dir/">https://example.com/dir/</a></p>
726 | .
727 | --fpermissive-url-autolinks
728 | ````````````````````````````````
729 | 
730 | 
731 | ## [Issue 242](https://github.com/mity/md4c/issues/242)
732 | 
733 | ```````````````````````````````` example
734 | copy ~user1/file to ~user2/file
735 | 
736 | copy "~user1/file" to "~user2/file"
737 | .
738 | <p>copy ~user1/file to ~user2/file</p>
739 | <p>copy &quot;~user1/file&quot; to &quot;~user2/file&quot;</p>
740 | .
741 | --fstrikethrough
742 | ````````````````````````````````
743 | 
744 | 
745 | ## [Issue 248](https://github.com/mity/md4c/issues/248)
746 | 
747 | (These are in spec.txt, but we need the [no-normalize] flag in order to
748 | catch the whitespace issues.)
749 | 
750 | ```````````````````````````````` example [no-normalize]
751 | #→Foo
752 | .
753 | <h1>Foo</h1>
754 | ````````````````````````````````
755 | 
756 | ```````````````````````````````` example [no-normalize]
757 |   Foo *bar
758 | baz*→
759 | ====
760 | .
761 | <h1>Foo <em>bar
762 | baz</em></h1>
763 | ````````````````````````````````
764 | 
765 | 
766 | ## [Issue 250](https://github.com/mity/md4c/issues/250)
767 | 
768 | Handling trailing tabulator character versus hard break.
769 | 
770 | Space + space + tab + newline is not hard break:
771 | ```````````````````````````````` example [no-normalize]
772 | foo  →
773 | bar
774 | .
775 | <p>foo
776 | bar</p>
777 | ````````````````````````````````
778 | 
779 | Tab + space + space + newline is hard break:
780 | ```````````````````````````````` example [no-normalize]
781 | foo→  
782 | bar
783 | .
784 | <p>foo<br>
785 | bar</p>
786 | ````````````````````````````````
787 | 
788 | 


--------------------------------------------------------------------------------
/test/run-testsuite.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | # -*- coding: utf-8 -*-
  3 | 
  4 | import sys
  5 | from difflib import unified_diff
  6 | import argparse
  7 | import re
  8 | import json
  9 | from prog import Prog
 10 | from normalize import normalize_html
 11 | 
 12 | if __name__ == "__main__":
 13 |     parser = argparse.ArgumentParser(description='Run Markdown tests.')
 14 |     parser.add_argument('-p', '--program', dest='program', nargs='?', default=None,
 15 |             help='program to test')
 16 |     parser.add_argument('-s', '--spec', dest='spec', nargs='?', default='spec.txt',
 17 |             help='path to spec')
 18 |     parser.add_argument('-P', '--pattern', dest='pattern', nargs='?',
 19 |             default=None, help='limit to sections matching regex pattern')
 20 |     parser.add_argument('--no-normalize', dest='normalize',
 21 |             action='store_const', const=False, default=True,
 22 |             help='do not normalize HTML')
 23 |     parser.add_argument('-d', '--dump-tests', dest='dump_tests',
 24 |             action='store_const', const=True, default=False,
 25 |             help='dump tests in JSON format')
 26 |     parser.add_argument('--debug-normalization', dest='debug_normalization',
 27 |             action='store_const', const=True,
 28 |             default=False, help='filter stdin through normalizer for testing')
 29 |     parser.add_argument('-n', '--number', type=int, default=None,
 30 |             help='only consider the test with the given number')
 31 |     args = parser.parse_args(sys.argv[1:])
 32 | 
 33 | def out(str):
 34 |     sys.stdout.buffer.write(str.encode('utf-8')) 
 35 | 
 36 | def print_test_header(headertext, example_number, start_line, end_line):
 37 |     out("Example %d (lines %d-%d) %s\n" % (example_number,start_line,end_line,headertext))
 38 | 
 39 | def do_test(test, normalize, result_counts):
 40 |     prog = Prog(cmdline=args.program, default_options=test['cmdline_options'])
 41 |     [retcode, actual_html, err] = prog.to_html(test['markdown'])
 42 |     if retcode == 0:
 43 |         expected_html = test['html']
 44 |         unicode_error = None
 45 |         if normalize and not test['no_normalize']:
 46 |             try:
 47 |                 passed = normalize_html(actual_html) == normalize_html(expected_html)
 48 |             except UnicodeDecodeError as e:
 49 |                 unicode_error = e
 50 |                 passed = False
 51 |         else:
 52 |             passed = actual_html == expected_html
 53 |         if passed:
 54 |             result_counts['pass'] += 1
 55 |         else:
 56 |             print_test_header(test['section'], test['example'], test['start_line'], test['end_line'])
 57 |             out(test['markdown'] + '\n')
 58 |             if unicode_error:
 59 |                 out("Unicode error: " + str(unicode_error) + '\n')
 60 |                 out("Expected: " + repr(expected_html) + '\n')
 61 |                 out("Got:      " + repr(actual_html) + '\n')
 62 |             else:
 63 |                 expected_html_lines = expected_html.splitlines(True)
 64 |                 actual_html_lines = actual_html.splitlines(True)
 65 |                 for diffline in unified_diff(expected_html_lines, actual_html_lines,
 66 |                                 "expected HTML", "actual HTML"):
 67 |                     out(diffline)
 68 |             out('\n')
 69 |             result_counts['fail'] += 1
 70 |     else:
 71 |         print_test_header(test['section'], test['example'], test['start_line'], test['end_line'])
 72 |         out("program returned error code %d\n" % retcode)
 73 |         sys.stdout.buffer.write(err)
 74 |         result_counts['error'] += 1
 75 | 
 76 | def get_tests(specfile):
 77 |     line_number = 0
 78 |     start_line = 0
 79 |     end_line = 0
 80 |     example_number = 0
 81 |     markdown_lines = []
 82 |     html_lines = []
 83 |     cmdline_lines = []
 84 |     state = 0  # 0 regular text, 1 markdown example, 2 html output
 85 |     headertext = ''
 86 |     tests = []
 87 |     no_normalize = 0
 88 | 
 89 |     header_re = re.compile('#+ ')
 90 | 
 91 |     with open(specfile, 'r', encoding='utf-8', newline='\n') as specf:
 92 |         for line in specf:
 93 |             line_number = line_number + 1
 94 |             l = line.strip()
 95 |             if re.match("`{32} example( [a-z]{1,})?", l):
 96 |                 state = 1
 97 |                 if re.search("\\[no-normalize\\]", l):
 98 |                     no_normalize = 1
 99 |             elif state >= 2 and l == "`" * 32:
100 |                 state = 0
101 |                 example_number = example_number + 1
102 |                 end_line = line_number
103 |                 tests.append({
104 |                     "markdown":''.join(markdown_lines).replace('→',"\t"),
105 |                     "html":''.join(html_lines).replace('→',"\t"),
106 |                     "no_normalize": no_normalize,
107 |                     "cmdline_options":''.join(cmdline_lines),
108 |                     "example": example_number,
109 |                     "start_line": start_line,
110 |                     "end_line": end_line,
111 |                     "section": headertext,})
112 |                 start_line = 0
113 |                 markdown_lines = []
114 |                 html_lines = []
115 |                 cmdline_lines = []
116 |                 no_normalize = 0
117 |             elif l == ".":
118 |                 state += 1
119 |             elif state == 1:
120 |                 if start_line == 0:
121 |                     start_line = line_number - 1
122 |                 markdown_lines.append(line)
123 |             elif state == 2:
124 |                 html_lines.append(line)
125 |             elif state == 3:
126 |                 cmdline_lines.append(line)
127 |             elif state == 0 and re.match(header_re, line):
128 |                 headertext = header_re.sub('', line).strip()
129 |     return tests
130 | 
131 | if __name__ == "__main__":
132 |     if args.debug_normalization:
133 |         out(normalize_html(sys.stdin.read()))
134 |         exit(0)
135 | 
136 |     all_tests = get_tests(args.spec)
137 |     if args.pattern:
138 |         pattern_re = re.compile(args.pattern, re.IGNORECASE)
139 |     else:
140 |         pattern_re = re.compile('.')
141 |     tests = [ test for test in all_tests if re.search(pattern_re, test['section']) and (not args.number or test['example'] == args.number) ]
142 |     if args.dump_tests:
143 |         out(json.dumps(tests, ensure_ascii=False, indent=2))
144 |         exit(0)
145 |     else:
146 |         skipped = len(all_tests) - len(tests)
147 |         result_counts = {'pass': 0, 'fail': 0, 'error': 0, 'skip': skipped}
148 |         for test in tests:
149 |             do_test(test, args.normalize, result_counts)
150 |         out("{pass} passed, {fail} failed, {error} errored, {skip} skipped\n".format(**result_counts))
151 |         exit(result_counts['fail'] + result_counts['error'])
152 | 


--------------------------------------------------------------------------------
/test/spec-hard-soft-breaks.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | # Hard Soft Breaks
 3 | 
 4 | With the flag `MD_FLAG_HARD_SOFT_BREAKS`, MD4C treats all newline characters as
 5 | hard breaks.
 6 | 
 7 | ```````````````````````````````` example
 8 | foo
 9 | baz
10 | .
11 | <p>foo<br>
12 | baz</p>
13 | .
14 | --fhard-soft-breaks
15 | ````````````````````````````````
16 | 
17 | ```````````````````````````````` example
18 | A quote from the CommonMark Spec below:
19 | 
20 | A renderer may also provide an option to 
21 | render soft line breaks as hard line breaks.
22 | .
23 | <p>A quote from the CommonMark Spec below:</p>
24 | <p>A renderer may also provide an option to<br>
25 | render soft line breaks as hard line breaks.</p>
26 | .
27 | --fhard-soft-breaks
28 | ````````````````````````````````
29 | 


--------------------------------------------------------------------------------
/test/spec-latex-math.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | # LaTeX Math
 3 | 
 4 | With the flag `MD_FLAG_LATEXMATHSPANS`, MD4C enables extension for recognition
 5 | of LaTeX style math spans.
 6 | 
 7 | A math span is is any text wrapped in dollars or double dollars (`$...$` or
 8 | `$$...$$`).
 9 | 
10 | ```````````````````````````````` example
11 | $a+b=c$ Hello, world!
12 | .
13 | <p><x-equation>a+b=c</x-equation> Hello, world!</p>
14 | .
15 | --flatex-math
16 | ````````````````````````````````
17 | 
18 | However the LaTeX math spans cannot be nested:
19 | 
20 | ```````````````````````````````` example
21 | $$foo $bar$ baz$$
22 | .
23 | <p>$$foo <x-equation>bar</x-equation> baz$$</p>
24 | .
25 | --flatex-math
26 | ````````````````````````````````
27 | 
28 | The opening delimiter cannot be preceded with an alphanumerical character:
29 | 
30 | ```````````````````````````````` example
31 | x$a+b=c$
32 | .
33 | <p>x$a+b=c$</p>
34 | .
35 | --flatex-math
36 | ````````````````````````````````
37 | 
38 | Similarly the closing delimiter cannot be followed with an alphanumerical character:
39 | 
40 | ```````````````````````````````` example
41 | $a+b=c$x
42 | .
43 | <p>$a+b=c$x</p>
44 | .
45 | --flatex-math
46 | ````````````````````````````````
47 | 
48 | If the double dollar sign is used, the math span is a display math span.
49 | 
50 | ```````````````````````````````` example
51 | This is a display equation: $$\int_a^b x dx$$.
52 | .
53 | <p>This is a display equation: <x-equation type="display">\int_a^b x dx</x-equation>.</p>
54 | .
55 | --flatex-math
56 | ````````````````````````````````
57 | 
58 | Math spans may span multiple lines as they are normal spans:
59 | 
60 | ```````````````````````````````` example
61 | $$
62 | \int_a^b
63 | f(x) dx
64 | $$
65 | .
66 | <p><x-equation type="display"> \int_a^b f(x) dx </x-equation></p>
67 | .
68 | --flatex-math
69 | ````````````````````````````````
70 | 
71 | Note though that many (simple) renderers may output the math spans just as a
72 | verbatim text. (This includes the HTML renderer used by the `md2html` utility.)
73 | 
74 | Only advanced renderers which implement LaTeX math syntax can be expected to
75 | provide better results.
76 | 


--------------------------------------------------------------------------------
/test/spec-permissive-autolinks.txt:
--------------------------------------------------------------------------------
  1 | 
  2 | # Permissive Autolinks
  3 | 
  4 | Standard autolinks (as per CommonMark specification) have to be decorated with
  5 | `<` and `>` so for example:
  6 | 
  7 | ```````````````````````````````` example
  8 | <mailto:john.doe@gmail.com>
  9 | <https://example.com>
 10 | .
 11 | <p><a href="mailto:john.doe@gmail.com">mailto:john.doe@gmail.com</a>
 12 | <a href="https://example.com">https://example.com</a></p>
 13 | ````````````````````````````````
 14 | 
 15 | With flags `MD_FLAG_PERMISSIVEURLAUTOLINKS`, `MD_FLAG_PERMISSIVEWWWAUTOLINKS`
 16 | and `MD_FLAG_PERMISSIVEEMAILAUTOLINKS`, MD4C is able also to recognize autolinks
 17 | without those marks.
 18 | 
 19 | Example of permissive autolinks follows:
 20 | 
 21 | ```````````````````````````````` example
 22 | john.doe@gmail.com
 23 | https://www.example.com
 24 | www.example.com
 25 | .
 26 | <p><a href="mailto:john.doe@gmail.com">john.doe@gmail.com</a>
 27 | <a href="https://www.example.com">https://www.example.com</a>
 28 | <a href="http://www.example.com">www.example.com</a></p>
 29 | .
 30 | --fpermissive-email-autolinks
 31 | --fpermissive-url-autolinks
 32 | --fpermissive-www-autolinks
 33 | ````````````````````````````````
 34 | 
 35 | However as this syntax also brings some more danger of false positives, more
 36 | strict rules apply to what characters may or may not form such autolinks.
 37 | When a need arises to use a link which does not satisfy these restrictions,
 38 | standard Markdown autolinks have to be used.
 39 | 
 40 | First and formost, these autolinks have to be delimited from surrounded text,
 41 | i.e. whitespace, beginning/end of line, or very limited punctuation must
 42 | precede and follow respectively.
 43 | 
 44 | Therefore these are not autolinks because `:` precedes or follows:
 45 | 
 46 | ```````````````````````````````` example
 47 | :john.doe@gmail.com
 48 | :https://www.example.com
 49 | :www.example.com
 50 | .
 51 | <p>:john.doe@gmail.com
 52 | :https://www.example.com
 53 | :www.example.com</p>
 54 | .
 55 | --fpermissive-email-autolinks
 56 | --fpermissive-url-autolinks
 57 | --fpermissive-www-autolinks
 58 | ````````````````````````````````
 59 | 
 60 | Allowed punctuation right before autolink includes only opening brackets `(`,
 61 | `{` or `[`:
 62 | 
 63 | ```````````````````````````````` example
 64 | [john.doe@gmail.com
 65 | (https://www.example.com
 66 | {www.example.com
 67 | .
 68 | <p>[<a href="mailto:john.doe@gmail.com">john.doe@gmail.com</a>
 69 | (<a href="https://www.example.com">https://www.example.com</a>
 70 | {<a href="http://www.example.com">www.example.com</a></p>
 71 | .
 72 | --fpermissive-email-autolinks
 73 | --fpermissive-url-autolinks
 74 | --fpermissive-www-autolinks
 75 | ````````````````````````````````
 76 | 
 77 | Correspondingly, the respective closing brackets may follow the autolinks.
 78 | 
 79 | ```````````````````````````````` example
 80 | john.doe@gmail.com]
 81 | https://www.example.com)
 82 | www.example.com}
 83 | .
 84 | <p><a href="mailto:john.doe@gmail.com">john.doe@gmail.com</a>]
 85 | <a href="https://www.example.com">https://www.example.com</a>)
 86 | <a href="http://www.example.com">www.example.com</a>}</p>
 87 | .
 88 | --fpermissive-email-autolinks
 89 | --fpermissive-url-autolinks
 90 | --fpermissive-www-autolinks
 91 | ````````````````````````````````
 92 | 
 93 | Some other punctuation characters are also allowed after the autolink so that
 94 | the autolinks may appear at the end of a sentence or clause (`.`, `!`, `?`,
 95 | `,`, `;`):
 96 | 
 97 | ```````````````````````````````` example
 98 | Have you ever visited http://zombo.com?
 99 | .
100 | <p>Have you ever visited <a href="http://zombo.com">http://zombo.com</a>?</p>
101 | .
102 | --fpermissive-url-autolinks
103 | ````````````````````````````````
104 | 
105 | Markdown emphasis mark can also precede (but only opening mark) or follow
106 | (only closer mark):
107 | 
108 | ```````````````````````````````` example
109 | You may contact me at **john.doe@example.com**.
110 | .
111 | <p>You may contact me at <strong><a href="mailto:john.doe@example.com">john.doe@example.com</a></strong>.</p>
112 | .
113 | --fpermissive-email-autolinks
114 | ````````````````````````````````
115 | 
116 | However the following is not, because in this example `*` is literal `*` and
117 | such punctuation is not allowed before the autolink:
118 | 
119 | ```````````````````````````````` example
120 | *john.doe@example.com
121 | 
122 | john.doe@example.com*
123 | .
124 | <p>*john.doe@example.com</p>
125 | <p>john.doe@example.com*</p>
126 | .
127 | --fpermissive-email-autolinks
128 | ````````````````````````````````
129 | 
130 | ## Permissive URL Autolinks
131 | 
132 | Permissive URL autolinks (`MD_FLAG_PERMISSIVEURLAUTOLINKS`) are formed
133 | by mandatory URL scheme, mandatory host, optional path, optional query and
134 | optional fragment.
135 | 
136 | The permissive URL autolinks recognize only `http://`, `https://` and `ftp://`
137 | as the scheme:
138 | 
139 | ```````````````````````````````` example
140 | https://example.com
141 | http://example.com
142 | ftp://example.com
143 | 
144 | ssh://example.com
145 | .
146 | <p><a href="https://example.com">https://example.com</a>
147 | <a href="http://example.com">http://example.com</a>
148 | <a href="ftp://example.com">ftp://example.com</a></p>
149 | <p>ssh://example.com</p>
150 | .
151 | --fpermissive-url-autolinks
152 | ````````````````````````````````
153 | 
154 | The host is a sequence made of alphanumerical characters, `.`, `-` and `_`.
155 | It has to include at least two components delimited with `.`, last component
156 | has to have at least two characters, and occurrence of `.`, `-` and `_` has to
157 | be immediately preceded and followed with a letter or digit.
158 | 
159 | The host specification may optionally be followed with path. Path begins with
160 | character `/` and uses it also for delimiting path components. Every path
161 | component is made of alhanumerical characters and `.`, `-`, `_`. Once again,
162 | any occurrence of `.`, `-`, `_` has to be surrounded with alphanumerical
163 | character.
164 | 
165 | ```````````````````````````````` example
166 | https://example.com/images/branding/logo_272x92.png
167 | .
168 | <p><a href="https://example.com/images/branding/logo_272x92.png">https://example.com/images/branding/logo_272x92.png</a></p>
169 | .
170 | --fpermissive-url-autolinks
171 | ````````````````````````````````
172 | 
173 | Then optionally query may follow. The query is made of `?` and then with
174 | alhanumerical characters, `&`, `.`, `-`, `+`, `_`, `=`, `(` and `)`. Once again any
175 | of those non-alhanumerical characters has to be surrounded with alpha-numerical
176 | characters, and also brackets `(` have to be balanced `)`.
177 | 
178 | ```````````````````````````````` example
179 | https://www.google.com/search?q=md4c+markdown
180 | .
181 | <p><a href="https://www.google.com/search?q=md4c+markdown">https://www.google.com/search?q=md4c+markdown</a></p>
182 | .
183 | --fpermissive-url-autolinks
184 | ````````````````````````````````
185 | 
186 | And finally there may be an optional fragment.
187 | 
188 | ```````````````````````````````` example
189 | https://example.com#fragment
190 | .
191 | <p><a href="https://example.com#fragment">https://example.com#fragment</a></p>
192 | .
193 | --fpermissive-url-autolinks
194 | ````````````````````````````````
195 | 
196 | And finally one complex example:
197 | 
198 | ```````````````````````````````` example
199 | http://commonmark.org
200 | 
201 | (Visit https://encrypted.google.com/search?q=Markup+(business))
202 | 
203 | Anonymous FTP is available at ftp://foo.bar.baz.
204 | .
205 | <p><a href="http://commonmark.org">http://commonmark.org</a></p>
206 | <p>(Visit <a href="https://encrypted.google.com/search?q=Markup+(business)">https://encrypted.google.com/search?q=Markup+(business)</a>)</p>
207 | <p>Anonymous FTP is available at <a href="ftp://foo.bar.baz">ftp://foo.bar.baz</a>.</p>
208 | .
209 | --fpermissive-url-autolinks
210 | ````````````````````````````````
211 | 
212 | 
213 | ## Permissive WWW Autolinks
214 | 
215 | Permissive WWW autolinks (`MD_FLAG_PERMISSIVEWWWAUTOLINKS`) are very similar
216 | to the permissive URL autolinks. Actually the only difference is that instead
217 | of providing an explicit scheme, they have to begin with `www.`.
218 | 
219 | ```````````````````````````````` example
220 | www.google.com/search?q=Markdown
221 | .
222 | <p><a href="http://www.google.com/search?q=Markdown">www.google.com/search?q=Markdown</a></p>
223 | .
224 | --fpermissive-www-autolinks
225 | ````````````````````````````````
226 | 
227 | 
228 | ## Permissive E-mail Autolinks
229 | 
230 | Permissive E-mail autolinks (`MD_FLAG_PERMISSIVEEMAILAUTOLINKS`) impose the
231 | following limitations to the e-mail addresses:
232 | 
233 | 1. The username (before the `@`) can only use alphanumerical characters and
234 |    characters `.`, `-`, `_` and `+`. However every such non-alphanumerical
235 |    character must be immediately preceded and followed by an alphanumerical
236 |    character.
237 | 
238 |    For example this is not an auto-link because of that double underscore `__`.
239 | 
240 |    ```````````````````````````````` example
241 |    john__doe@example.com
242 |    .
243 |    <p>john__doe@example.com</p>
244 |    .
245 |    --fpermissive-email-autolinks
246 |    ````````````````````````````````
247 | 
248 | 2. Same rules for domain as for URL and WWW autolinks apply.
249 | 


--------------------------------------------------------------------------------
/test/spec-strikethrough.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | # Strike-Through
 3 | 
 4 | With the flag `MD_FLAG_STRIKETHROUGH`, MD4C enables extension for recognition
 5 | of strike-through spans.
 6 | 
 7 | Strike-through text is any text wrapped in one or two tildes (`~`).
 8 | 
 9 | ```````````````````````````````` example
10 | ~Hi~ Hello, world!
11 | .
12 | <p><del>Hi</del> Hello, world!</p>
13 | .
14 | --fstrikethrough
15 | ````````````````````````````````
16 | 
17 | If the length of the opener and closer doesn't match, the strike-through is
18 | not recognized.
19 | 
20 | ```````````````````````````````` example
21 | This ~text~~ is curious.
22 | .
23 | <p>This ~text~~ is curious.</p>
24 | .
25 | --fstrikethrough
26 | ````````````````````````````````
27 | 
28 | Too long tilde sequence won't be recognized:
29 | 
30 | ```````````````````````````````` example
31 | foo ~~~bar~~~
32 | .
33 | <p>foo ~~~bar~~~</p>
34 | .
35 | --fstrikethrough
36 | ````````````````````````````````
37 | 
38 | Also note the markers cannot open a strike-through span if they are followed
39 | with a whitespace; and similarly, then cannot close the span if they are
40 | preceded with a whitespace:
41 | 
42 | ```````````````````````````````` example
43 | ~foo ~bar
44 | .
45 | <p>~foo ~bar</p>
46 | .
47 | --fstrikethrough
48 | ````````````````````````````````
49 | 
50 | 
51 | As with regular emphasis delimiters, a new paragraph will cause the cessation
52 | of parsing a strike-through:
53 | 
54 | ```````````````````````````````` example
55 | This ~~has a
56 | 
57 | new paragraph~~.
58 | .
59 | <p>This ~~has a</p>
60 | <p>new paragraph~~.</p>
61 | .
62 | --fstrikethrough
63 | ````````````````````````````````
64 | 


--------------------------------------------------------------------------------
/test/spec-tables.txt:
--------------------------------------------------------------------------------
  1 | 
  2 | # Tables
  3 | 
  4 | With the flag `MD_FLAG_TABLES`, MD4C enables extension for recognition of
  5 | tables.
  6 | 
  7 | Basic table example of a table with two columns and three lines (when not
  8 | counting the header) is as follows:
  9 | 
 10 | ```````````````````````````````` example
 11 | | Column 1 | Column 2 |
 12 | |----------|----------|
 13 | | foo      | bar      |
 14 | | baz      | qux      |
 15 | | quux     | quuz     |
 16 | .
 17 | <table>
 18 | <thead>
 19 | <tr><th>Column 1</th><th>Column 2</th></tr>
 20 | </thead>
 21 | <tbody>
 22 | <tr><td>foo</td><td>bar</td></tr>
 23 | <tr><td>baz</td><td>qux</td></tr>
 24 | <tr><td>quux</td><td>quuz</td></tr>
 25 | </tbody>
 26 | </table>
 27 | .
 28 | --ftables
 29 | ````````````````````````````````
 30 | 
 31 | The leading and succeeding pipe characters (`|`) on each line are optional:
 32 | 
 33 | ```````````````````````````````` example
 34 | Column 1 | Column 2 |
 35 | ---------|--------- |
 36 | foo      | bar      |
 37 | baz      | qux      |
 38 | quux     | quuz     |
 39 | .
 40 | <table>
 41 | <thead>
 42 | <tr><th>Column 1</th><th>Column 2</th></tr>
 43 | </thead>
 44 | <tbody>
 45 | <tr><td>foo</td><td>bar</td></tr>
 46 | <tr><td>baz</td><td>qux</td></tr>
 47 | <tr><td>quux</td><td>quuz</td></tr>
 48 | </tbody>
 49 | </table>
 50 | .
 51 | --ftables
 52 | ````````````````````````````````
 53 | 
 54 | ```````````````````````````````` example
 55 | | Column 1 | Column 2
 56 | |----------|---------
 57 | | foo      | bar
 58 | | baz      | qux
 59 | | quux     | quuz
 60 | .
 61 | <table>
 62 | <thead>
 63 | <tr><th>Column 1</th><th>Column 2</th></tr>
 64 | </thead>
 65 | <tbody>
 66 | <tr><td>foo</td><td>bar</td></tr>
 67 | <tr><td>baz</td><td>qux</td></tr>
 68 | <tr><td>quux</td><td>quuz</td></tr>
 69 | </tbody>
 70 | </table>
 71 | .
 72 | --ftables
 73 | ````````````````````````````````
 74 | 
 75 | ```````````````````````````````` example
 76 | Column 1 | Column 2
 77 | ---------|---------
 78 | foo      | bar
 79 | baz      | qux
 80 | quux     | quuz
 81 | .
 82 | <table>
 83 | <thead>
 84 | <tr><th>Column 1</th><th>Column 2</th></tr>
 85 | </thead>
 86 | <tbody>
 87 | <tr><td>foo</td><td>bar</td></tr>
 88 | <tr><td>baz</td><td>qux</td></tr>
 89 | <tr><td>quux</td><td>quuz</td></tr>
 90 | </tbody>
 91 | </table>
 92 | .
 93 | --ftables
 94 | ````````````````````````````````
 95 | 
 96 | However for one-column table, at least one pipe has to be used in the table
 97 | header underline, otherwise it would be parsed as a Setext title followed by
 98 | a paragraph.
 99 | 
100 | ```````````````````````````````` example
101 | Column 1
102 | --------
103 | foo
104 | baz
105 | quux
106 | .
107 | <h2>Column 1</h2>
108 | <p>foo
109 | baz
110 | quux</p>
111 | .
112 | --ftables
113 | ````````````````````````````````
114 | 
115 | Leading and trailing whitespace in a table cell is ignored and the columns do
116 | not need to be aligned.
117 | 
118 | ```````````````````````````````` example
119 | Column 1 |Column 2
120 | ---|---
121 | foo | bar
122 | baz| qux
123 | quux|quuz
124 | .
125 | <table>
126 | <thead>
127 | <tr><th>Column 1</th><th>Column 2</th></tr>
128 | </thead>
129 | <tbody>
130 | <tr><td>foo</td><td>bar</td></tr>
131 | <tr><td>baz</td><td>qux</td></tr>
132 | <tr><td>quux</td><td>quuz</td></tr>
133 | </tbody>
134 | </table>
135 | .
136 | --ftables
137 | ````````````````````````````````
138 | 
139 | The table cannot interrupt a paragraph.
140 | 
141 | ```````````````````````````````` example
142 | Lorem ipsum dolor sit amet.
143 | | Column 1 | Column 2
144 | | ---------|---------
145 | | foo      | bar
146 | | baz      | qux
147 | | quux     | quuz
148 | .
149 | <p>Lorem ipsum dolor sit amet.
150 | | Column 1 | Column 2
151 | | ---------|---------
152 | | foo      | bar
153 | | baz      | qux
154 | | quux     | quuz</p>
155 | ````````````````````````````````
156 | 
157 | Similarly, paragraph cannot interrupt a table:
158 | 
159 | ```````````````````````````````` example
160 | Column 1 | Column 2
161 | ---------|---------
162 | foo      | bar
163 | baz      | qux
164 | quux     | quuz
165 | Lorem ipsum dolor sit amet.
166 | .
167 | <table>
168 | <thead>
169 | <tr><th>Column 1</th><th>Column 2</th></tr>
170 | </thead>
171 | <tbody>
172 | <tr><td>foo</td><td>bar</td></tr>
173 | <tr><td>baz</td><td>qux</td></tr>
174 | <tr><td>quux</td><td>quuz</td></tr>
175 | <tr><td>Lorem ipsum dolor sit amet.</td><td></td></tr>
176 | </tbody>
177 | </table>
178 | .
179 | --ftables
180 | ````````````````````````````````
181 | 
182 | The first, the last or both the first and the last dash in each column
183 | underline can be replaced with a colon (`:`) to request left, right or middle
184 | alignment of the respective column:
185 | 
186 | ```````````````````````````````` example
187 | | Column 1 | Column 2 | Column 3 | Column 4 |
188 | |----------|:---------|:--------:|---------:|
189 | | default  | left     | center   | right    |
190 | .
191 | <table>
192 | <thead>
193 | <tr><th>Column 1</th><th align="left">Column 2</th><th align="center">Column 3</th><th align="right">Column 4</th></tr>
194 | </thead>
195 | <tbody>
196 | <tr><td>default</td><td align="left">left</td><td align="center">center</td><td align="right">right</td></tr>
197 | </tbody>
198 | </table>
199 | .
200 | --ftables
201 | ````````````````````````````````
202 | 
203 | To include a literal pipe character in any cell, it has to be escaped.
204 | 
205 | ```````````````````````````````` example
206 | Column 1 | Column 2
207 | ---------|---------
208 | foo      | bar
209 | baz      | qux \| xyzzy
210 | quux     | quuz
211 | .
212 | <table>
213 | <thead>
214 | <tr><th>Column 1</th><th>Column 2</th></tr>
215 | </thead>
216 | <tbody>
217 | <tr><td>foo</td><td>bar</td></tr>
218 | <tr><td>baz</td><td>qux | xyzzy</td></tr>
219 | <tr><td>quux</td><td>quuz</td></tr>
220 | </tbody>
221 | </table>
222 | .
223 | --ftables
224 | ````````````````````````````````
225 | 
226 | Contents of each cell is parsed as an inline text which may contents any
227 | inline Markdown spans like emphasis, strong emphasis, links etc.
228 | 
229 | ```````````````````````````````` example
230 | Column 1 | Column 2
231 | ---------|---------
232 | *foo*    | bar
233 | **baz**  | [qux]
234 | quux     | [quuz](/url2)
235 | 
236 | [qux]: /url
237 | .
238 | <table>
239 | <thead>
240 | <tr><th>Column 1</th><th>Column 2</th></tr>
241 | </thead>
242 | <tbody>
243 | <tr><td><em>foo</em></td><td>bar</td></tr>
244 | <tr><td><strong>baz</strong></td><td><a href="/url">qux</a></td></tr>
245 | <tr><td>quux</td><td><a href="/url2">quuz</a></td></tr>
246 | </tbody>
247 | </table>
248 | .
249 | --ftables
250 | ````````````````````````````````
251 | 
252 | However pipes which are inside a code span are not recognized as cell
253 | boundaries.
254 | 
255 | ```````````````````````````````` example
256 | Column 1 | Column 2
257 | ---------|---------
258 | `foo     | bar`
259 | baz      | qux
260 | quux     | quuz
261 | .
262 | <table>
263 | <thead>
264 | <tr><th>Column 1</th><th>Column 2</th></tr>
265 | </thead>
266 | <tbody>
267 | <tr><td><code>foo     | bar</code></td><td></td></tr>
268 | <tr><td>baz</td><td>qux</td></tr>
269 | <tr><td>quux</td><td>quuz</td></tr>
270 | </tbody>
271 | </table>
272 | .
273 | --ftables
274 | ````````````````````````````````
275 | 


--------------------------------------------------------------------------------
/test/spec-tasklists.txt:
--------------------------------------------------------------------------------
  1 | 
  2 | # Tasklists
  3 | 
  4 | With the flag `MD_FLAG_TASKLISTS`, MD4C enables extension for recognition of
  5 | task lists.
  6 | 
  7 | Basic task list may look as follows:
  8 | 
  9 | ```````````````````````````````` example
 10 |  * [x] foo
 11 |  * [X] bar
 12 |  * [ ] baz
 13 | .
 14 | <ul>
 15 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>foo</li>
 16 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>bar</li>
 17 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled>baz</li>
 18 | </ul>
 19 | .
 20 | --ftasklists
 21 | ````````````````````````````````
 22 | 
 23 | Task lists can also be in ordered lists:
 24 | 
 25 | ```````````````````````````````` example
 26 |  1. [x] foo
 27 |  2. [X] bar
 28 |  3. [ ] baz
 29 | .
 30 | <ol>
 31 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>foo</li>
 32 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>bar</li>
 33 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled>baz</li>
 34 | </ol>
 35 | .
 36 | --ftasklists
 37 | ````````````````````````````````
 38 | 
 39 | Task lists can also be nested in ordinary lists:
 40 | 
 41 | ```````````````````````````````` example
 42 |  * xxx:
 43 |    * [x] foo
 44 |    * [x] bar
 45 |    * [ ] baz
 46 |  * yyy:
 47 |    * [ ] qux
 48 |    * [x] quux
 49 |    * [ ] quuz
 50 | .
 51 | <ul>
 52 | <li>xxx:
 53 | <ul>
 54 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>foo</li>
 55 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>bar</li>
 56 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled>baz</li>
 57 | </ul></li>
 58 | <li>yyy:
 59 | <ul>
 60 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled>qux</li>
 61 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>quux</li>
 62 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled>quuz</li>
 63 | </ul></li>
 64 | </ul>
 65 | .
 66 | --ftasklists
 67 | ````````````````````````````````
 68 | 
 69 | Or in a parent task list:
 70 | 
 71 | ```````````````````````````````` example
 72 |  1. [x] xxx:
 73 |     * [x] foo
 74 |     * [x] bar
 75 |     * [ ] baz
 76 |  2. [ ] yyy:
 77 |     * [ ] qux
 78 |     * [x] quux
 79 |     * [ ] quuz
 80 | .
 81 | <ol>
 82 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>xxx:
 83 | <ul>
 84 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>foo</li>
 85 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>bar</li>
 86 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled>baz</li>
 87 | </ul></li>
 88 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled>yyy:
 89 | <ul>
 90 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled>qux</li>
 91 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>quux</li>
 92 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled>quuz</li>
 93 | </ul></li>
 94 | </ol>
 95 | .
 96 | --ftasklists
 97 | ````````````````````````````````
 98 | 
 99 | Also, ordinary lists can be nested in the task lists.
100 | 
101 | ```````````````````````````````` example
102 |  * [x] xxx:
103 |    * foo
104 |    * bar
105 |    * baz
106 |  * [ ] yyy:
107 |    * qux
108 |    * quux
109 |    * quuz
110 | .
111 | <ul>
112 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled checked>xxx:
113 | <ul>
114 | <li>foo</li>
115 | <li>bar</li>
116 | <li>baz</li>
117 | </ul></li>
118 | <li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled>yyy:
119 | <ul>
120 | <li>qux</li>
121 | <li>quux</li>
122 | <li>quuz</li>
123 | </ul></li>
124 | </ul>
125 | .
126 | --ftasklists
127 | ````````````````````````````````
128 | 


--------------------------------------------------------------------------------
/test/spec-underline.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | # Underline
 3 | 
 4 | With the flag `MD_FLAG_UNDERLINE`, MD4C sees underscore `_` rather as a mark
 5 | denoting an underlined span rather than an ordinary emphasis (or a strong
 6 | emphasis).
 7 | 
 8 | ```````````````````````````````` example
 9 | _foo_
10 | .
11 | <p><u>foo</u></p>
12 | .
13 | --funderline
14 | ````````````````````````````````
15 | 
16 | In sequences of multiple underscores, each single one translates into an
17 | underline span mark.
18 | 
19 | ```````````````````````````````` example
20 | ___foo___
21 | .
22 | <p><u><u><u>foo</u></u></u></p>
23 | .
24 | --funderline
25 | ````````````````````````````````
26 | 
27 | Intra-word underscores are not recognized as underline marks:
28 | 
29 | ```````````````````````````````` example
30 | foo_bar_baz
31 | .
32 | <p>foo_bar_baz</p>
33 | .
34 | --funderline
35 | ````````````````````````````````
36 | 
37 | Also the parser follows the standard understanding when the underscore can
38 | or cannot open or close a span. Therefore there is no underline in the following
39 | example because no underline can be seen as a closing mark.
40 | 
41 | ```````````````````````````````` example
42 | _foo _bar
43 | .
44 | <p>_foo _bar</p>
45 | .
46 | --funderline
47 | ````````````````````````````````
48 | 


--------------------------------------------------------------------------------
/test/spec-wiki-links.txt:
--------------------------------------------------------------------------------
  1 | 
  2 | # Wiki Links
  3 | 
  4 | With the flag `MD_FLAG_WIKILINKS`, MD4C recognizes wiki links.
  5 | 
  6 | The simple wiki-link is a wiki-link destination enclosed in `[[` followed with
  7 | `]]`.
  8 | 
  9 | ```````````````````````````````` example
 10 | [[foo]]
 11 | .
 12 | <p><x-wikilink data-target="foo">foo</x-wikilink></p>
 13 | .
 14 | --fwiki-links
 15 | ````````````````````````````````
 16 | 
 17 | However wiki-link may contain an explicit label, delimited from the destination
 18 | with `|`.
 19 | 
 20 | ```````````````````````````````` example
 21 | [[foo|bar]]
 22 | .
 23 | <p><x-wikilink data-target="foo">bar</x-wikilink></p>
 24 | .
 25 | --fwiki-links
 26 | ````````````````````````````````
 27 | 
 28 | A wiki-link destination cannot be empty.
 29 | 
 30 | ```````````````````````````````` example
 31 | [[]]
 32 | .
 33 | <p>[[]]</p>
 34 | .
 35 | --fwiki-links
 36 | ````````````````````````````````
 37 | 
 38 | ```````````````````````````````` example
 39 | [[|foo]]
 40 | .
 41 | <p>[[|foo]]</p>
 42 | .
 43 | --fwiki-links
 44 | ````````````````````````````````
 45 | 
 46 | 
 47 | The wiki-link destination cannot contain a new line.
 48 | 
 49 | ```````````````````````````````` example
 50 | [[foo
 51 | bar]]
 52 | .
 53 | <p>[[foo
 54 | bar]]</p>
 55 | .
 56 | --fwiki-links
 57 | ````````````````````````````````
 58 | 
 59 | ```````````````````````````````` example
 60 | [[foo
 61 | bar|baz]]
 62 | .
 63 | <p>[[foo
 64 | bar|baz]]</p>
 65 | .
 66 | --fwiki-links
 67 | ````````````````````````````````
 68 | 
 69 | The wiki-link destination is rendered verbatim; inline markup in it is not
 70 | recognized.
 71 | 
 72 | ```````````````````````````````` example
 73 | [[*foo*]]
 74 | .
 75 | <p><x-wikilink data-target="*foo*">*foo*</x-wikilink></p>
 76 | .
 77 | --fwiki-links
 78 | ````````````````````````````````
 79 | 
 80 | ```````````````````````````````` example
 81 | [[foo|![bar](bar.jpg)]]
 82 | .
 83 | <p><x-wikilink data-target="foo"><img src="bar.jpg" alt="bar"></x-wikilink></p>
 84 | .
 85 | --fwiki-links
 86 | ````````````````````````````````
 87 | 
 88 | With multiple `|` delimiters, only the first one is recognized and the other
 89 | ones are part of the label.
 90 | 
 91 | ```````````````````````````````` example
 92 | [[foo|bar|baz]]
 93 | .
 94 | <p><x-wikilink data-target="foo">bar|baz</x-wikilink></p>
 95 | .
 96 | --fwiki-links
 97 | ````````````````````````````````
 98 | 
 99 | However the delimiter `|` can be escaped with `/`.
100 | 
101 | ```````````````````````````````` example
102 | [[foo\|bar|baz]]
103 | .
104 | <p><x-wikilink data-target="foo|bar">baz</x-wikilink></p>
105 | .
106 | --fwiki-links
107 | ````````````````````````````````
108 | 
109 | The label can contain inline elements.
110 | 
111 | ```````````````````````````````` example
112 | [[foo|*bar*]]
113 | .
114 | <p><x-wikilink data-target="foo"><em>bar</em></x-wikilink></p>
115 | .
116 | --fwiki-links
117 | ````````````````````````````````
118 | 
119 | Empty explicit label is the same as using the implicit label; i.e. the verbatim
120 | destination string is used as the label.
121 | 
122 | ```````````````````````````````` example
123 | [[foo|]]
124 | .
125 | <p><x-wikilink data-target="foo">foo</x-wikilink></p>
126 | .
127 | --fwiki-links
128 | ````````````````````````````````
129 | 
130 | The label can span multiple lines.
131 | 
132 | ```````````````````````````````` example
133 | [[foo|foo
134 | bar
135 | baz]]
136 | .
137 | <p><x-wikilink data-target="foo">foo
138 | bar
139 | baz</x-wikilink></p>
140 | .
141 | --fwiki-links
142 | ````````````````````````````````
143 | 
144 | Wiki-links have higher priority than links.
145 | 
146 | ```````````````````````````````` example
147 | [[foo]](foo.jpg)
148 | .
149 | <p><x-wikilink data-target="foo">foo</x-wikilink>(foo.jpg)</p>
150 | .
151 | --fwiki-links
152 | ````````````````````````````````
153 | 
154 | ```````````````````````````````` example
155 | [foo]: /url
156 | 
157 | [[foo]]
158 | .
159 | <p><x-wikilink data-target="foo">foo</x-wikilink></p>
160 | .
161 | --fwiki-links
162 | ````````````````````````````````
163 | 
164 | Wiki links can be inlined in tables.
165 | 
166 | ```````````````````````````````` example
167 | | A                | B   |
168 | |------------------|-----|
169 | | [[foo|*bar*]]    | baz |
170 | .
171 | <table>
172 | <thead>
173 | <tr>
174 | <th>A</th>
175 | <th>B</th>
176 | </tr>
177 | </thead>
178 | <tbody>
179 | <tr>
180 | <td><x-wikilink data-target="foo"><em>bar</em></x-wikilink></td>
181 | <td>baz</td>
182 | </tr>
183 | </tbody>
184 | </table>
185 | .
186 | --fwiki-links --ftables
187 | ````````````````````````````````
188 | 
189 | Wiki-links are not prioritized over images.
190 | 
191 | ```````````````````````````````` example
192 | ![[foo]](foo.jpg)
193 | .
194 | <p><img src="foo.jpg" alt="[foo]"></p>
195 | .
196 | --fwiki-links
197 | ````````````````````````````````
198 | 
199 | Something that may look like a wiki-link at first, but turns out not to be,
200 | is recognized as a normal link.
201 | 
202 | ```````````````````````````````` example
203 | [[foo]
204 | 
205 | [foo]: /url
206 | .
207 | <p>[<a href="/url">foo</a></p>
208 | .
209 | --fwiki-links
210 | ````````````````````````````````
211 | 
212 | Escaping the opening `[` escapes only that one character, not the whole `[[`
213 | opener:
214 | 
215 | ```````````````````````````````` example
216 | \[[foo]]
217 | 
218 | [foo]: /url
219 | .
220 | <p>[<a href="/url">foo</a>]</p>
221 | .
222 | --fwiki-links
223 | ````````````````````````````````
224 | 
225 | Like with other inline links, the innermost wiki-link is preferred.
226 | 
227 | ```````````````````````````````` example
228 | [[foo[[bar]]]]
229 | .
230 | <p>[[foo<x-wikilink data-target="bar">bar</x-wikilink>]]</p>
231 | .
232 | --fwiki-links
233 | ````````````````````````````````
234 | 
235 | There is limit of 100 characters for the wiki-link destination.
236 | 
237 | ```````````````````````````````` example
238 | [[12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901]]
239 | [[12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901|foo]]
240 | .
241 | <p>[[12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901]]
242 | [[12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901|foo]]</p>
243 | .
244 | --fwiki-links
245 | ````````````````````````````````
246 | 
247 | 100 characters inside a wiki link target works.
248 | 
249 | ```````````````````````````````` example
250 | [[1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890]]
251 | [[1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890|foo]]
252 | .
253 | <p><x-wikilink data-target="1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890">1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890</x-wikilink>
254 | <x-wikilink data-target="1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890">foo</x-wikilink></p>
255 | .
256 | --fwiki-links
257 | ````````````````````````````````
258 | 
259 | The limit on link content does not include any characters belonging to a block
260 | quote, if the label spans multiple lines contained in a block quote.
261 | 
262 | ```````````````````````````````` example
263 | > [[12345678901234567890123456789012345678901234567890|1234567890
264 | > 1234567890
265 | > 1234567890
266 | > 1234567890
267 | > 123456789]]
268 | .
269 | <blockquote>
270 | <p><x-wikilink data-target="12345678901234567890123456789012345678901234567890">1234567890
271 | 1234567890
272 | 1234567890
273 | 1234567890
274 | 123456789</x-wikilink></p>
275 | </blockquote>
276 | .
277 | --fwiki-links
278 | ````````````````````````````````
279 | 


--------------------------------------------------------------------------------