The markdown.cl Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The markdown.cl Reference Manual

This is the markdown.cl Reference Manual, version 0.1.7, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 09:03:08 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

markdown.cl

This is a markdown parsing library for Common Lisp. It also parses table markdown using the github syntax.

The goal is to provide a very simple interface for turning markdown into valid HTML.

It currently doesn't support plugins or hooks or anything of that kind. I'd like to add these in the near future, so stay tuned.

markdown.cl is in beta!!! Expect bugs/parsing errors.

Documentation

The interface exposes two functions:

parse

(defun parse (markdown-string &key disable-parsers))
  => HTML string

This takes a markdown string and converts it into HTML.

The :disable-parsers keyword allows disabling of any sub-parser during the processing. None of these parsers are currently public, however I'd like to eventually make interfaces for them to be customizable (which would more or less act as a plugin system).

parse-file

(defun parse-file (path &key disable-parsers))
  => HTML string

This parses a markdown file by loading the contents and sending them to parse. It's just a simple wrapper.

Tests

The tests for markdown.cl are, right now, just large blobs of markdown that are parsed and tested using xmls (my favorite XML parser).

(ql:quickload :markdown.cl-test)
(markdown.cl-test:run-tests)

Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 markdown.cl

Author

Andrew Danger Lyon <orthecreedence@gmail.com>

License

MIT

Description

A markdown parser for Common Lisp

Version

0.1.7

Dependencies
Source

markdown.cl.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 markdown.cl.asd

Location

markdown.cl.asd

Systems

markdown.cl (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 markdown.cl/package.lisp

Parent

markdown.cl (system)

Location

package.lisp

Packages

markdown.cl


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 markdown.cl/util.lisp

Dependency

package.lisp (file)

Parent

markdown.cl (system)

Location

util.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 markdown.cl/html.lisp

Dependency

util.lisp (file)

Parent

markdown.cl (system)

Location

html.lisp

Exported Definitions

error-parsing-html (condition)

Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.5 markdown.cl/parser.lisp

Dependency

html.lisp (file)

Parent

markdown.cl (system)

Location

parser.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 markdown.cl

Source

package.lisp (file)

Nickname

markdown

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Functions

Function: parse MARKDOWN-STRING &key DISABLE-PARSERS

Parse a markdown string into HTML.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-file PATH &key DISABLE-PARSERS

Parse a markdown file into HTML (returned as a string).

Package

markdown.cl

Source

parser.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Conditions

Condition: error-parsing-html ()

Thrown then xmls cannot parse the HTML in a document (make sure your <img> tags are closed.

Package

markdown.cl

Source

html.lisp (file)

Direct superclasses

error (condition)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: *block-level-elements*

Stores all HTML tags considered block-level.

Package

markdown.cl

Source

html.lisp (file)

Special Variable: *html-chunks*

Holds a hash table that harbors HTML tags from the destructive forces of markdown parsing until they are ready to be injected back into the document.

Package

markdown.cl

Source

html.lisp (file)

Special Variable: *link-references*

Holds a hash table mapping link ids to URLs.

Package

markdown.cl

Source

parser.lisp (file)

Special Variable: *list-recursion-level*
Package

markdown.cl

Source

parser.lisp (file)

Special Variable: *nl*

Holds a string of a single newline character.

Package

markdown.cl

Source

util.lisp (file)

Special Variable: *scanner-block-list-pos*

Detects if a block has a ul/ol section.

Package

markdown.cl

Source

parser.lisp (file)

Special Variable: *scanner-blockquote*

A scanner for finding blockquotes.

Package

markdown.cl

Source

parser.lisp (file)

Special Variable: *scanner-find-first-html-block-element*

A scanner that searches for HTML elements that are not inline.

Package

markdown.cl

Source

parser.lisp (file)

Special Variable: *scanner-find-last-html-block-element*

A scanner that searches for HTML elements that are not inline.

Package

markdown.cl

Source

parser.lisp (file)

Special Variable: *scanner-lazy-blockquote*

A scanner for finding blockquotes.

Package

markdown.cl

Source

parser.lisp (file)

Special Variable: *tmp-storage*

Holds a hash table used for temporary blockquote storage.

Package

markdown.cl

Source

parser.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Functions

Function: block-element-p TAG-NAME

Test if a given HTML tag is a block-level element.

Package

markdown.cl

Source

html.lisp (file)

Function: cleanup-code STR

Let’s convert our {{markdown.cl|code|...}} tags to <code> tags.

Package

markdown.cl

Source

parser.lisp (file)

Function: cleanup-escaped-characters STR

Convert escaped characters back to non-escaped.

Package

markdown.cl

Source

parser.lisp (file)

Function: cleanup-hr STR

Due to the way processing <hr> tags occurs, they are always wrapped in <p> blocks. Instead of trying to figure out a way to NOT wrap them in <p> blocks (which would surely screw up the rest of the paragraph formatting) it makes more sense to let it happen, then fix in the final pass.

Package

markdown.cl

Source

parser.lisp (file)

Function: cleanup-markdown-tags STR
Package

markdown.cl

Source

html.lisp (file)

Function: cleanup-newlines STR

Here we remove excess newlines and convert any markdown.cl newlines into real ones.

Package

markdown.cl

Source

parser.lisp (file)

Function: cleanup-paragraphs STR

Remove any empty paragraph blocks (it does happen sometimes) and convert all markdown.cl paragraphs into real <p> tags.

Package

markdown.cl

Source

parser.lisp (file)

Function: convert-lazy-blockquote-to-standard STR

Converts a lazy blockquote:
> this a blockquote that spans multiple lines but
im too lazy to add the ’>’ at the beginning of each line
into:

> this a blockquote that
> spans multiple lines but > im too lazy to add the ’>’ > at the beginning of each line

Package

markdown.cl

Source

parser.lisp (file)

Function: do-parse-br STR

Parse <br> tags (when a line ends with two spaces).

Package

markdown.cl

Source

parser.lisp (file)

Function: do-parse-code STR

Parse ‘...‘ code blocks.

Package

markdown.cl

Source

parser.lisp (file)

Function: do-parse-double-code STR

Parse “...“ code blocks.

Package

markdown.cl

Source

parser.lisp (file)

Function: do-parse-em STR

Parse *, _, **, and __.

Package

markdown.cl

Source

parser.lisp (file)

Function: do-parse-entities STR &key USE-MARKDOWN-TAGS

Replace non-purposeful entities with escaped equivalents.

Package

markdown.cl

Source

parser.lisp (file)

Function: escape-html STR

Meant to be called on text inside code blocks.

Package

markdown.cl

Source

parser.lisp (file)

Function: escape-html-entities STR

Hide HTML entities from the HTML parser. It doesn’t like them. It has the death penalty on 12 systems.

Package

markdown.cl

Source

html.lisp (file)

Function: escape-links-href STR

Escape any underscores in href=... text so it’s not replaced with <em>s

Package

markdown.cl

Source

parser.lisp (file)

Function: file-contents PATH

Sucks up an entire file from PATH into a freshly-allocated string, returning two values: the string and the number of bytes read.

Package

markdown.cl

Source

util.lisp (file)

Function: fix-a-tags STR

XMLS mangles our <a> tags. Fix

Package

markdown.cl

Source

html.lisp (file)

Function: fix-inline-links STR

Fix <http://teh-link.com> links, which messes with XMLS’ mind.

Package

markdown.cl

Source

html.lisp (file)

Function: format-blockquote STR

Given a string that we know is a blockquote, remove the blockquote formatting and recursively parse markdown within the blockquote. If the given blockquote is not ’lazy’ then lazy blockquote parsing is disabled in the recursive parse so as not to screw up formatting.

Package

markdown.cl

Source

parser.lisp (file)

Function: format-code STR &key EMBEDDED

Sanely formats code blocks.

Package

markdown.cl

Source

parser.lisp (file)

Function: format-html-blocks-in-paragraph STR

This is a very helpful function which turns:

<p>this is my text<div>this is inside a block</div> more text</p>

into:

<p>this is my text</p><div>this is inside a block</div><p>more text</p>
In other words, it unwraps <p> tags from around HTML block elements, and does so such that all text between the first block tag found and after the last block tag found is left untouched (and unwrapped by <p>).

Package

markdown.cl

Source

parser.lisp (file)

Function: format-lists STR INDENT

This is the function that actually makes lists happen. Once all the blocks have been diced up into neat little packages ready for formatting, they are handed off to format-lists.

This function is responsible for adding the <ul>/<ol>/<li> tags around list items, making sure to only do this for items using the correct indentation level.

List items inject any saved blockquotes (via inject-saved-blockquotes) before moving on to paragraph processing. This step is essential because a lot of the blockquote formatting can screw up the splitting of list items correctly, resulting in <p> blocks in really weird places.

List items are run through the paragraph filters, have a minimal amount of formatting applied to make sure the recursion goes smoothly, and then are recursively concated onto the final string.

Package

markdown.cl

Source

parser.lisp (file)

Function: gather-link-references STR

Look for any link references in the document:

[link-id]: http://my-url.com
[4]: http://my-link.com (optional title)
[mylink]: http://my-url.com/lol ’kewl link brah’
[omg]: http://lol.com/wtf "rofl"

and parse them into the *link-references* hash table. The data will be pulled out when parse-links is called.

Note that as a side effect, this also gathers image references =].

Package

markdown.cl

Source

parser.lisp (file)

Function: inject-saved-blockquotes STR
Package

markdown.cl

Source

parser.lisp (file)

Function: join-list-lines STR

Turns lists broken into multiple lines into (per item) so that there’s one line per item:

- my list item
broken into multiple
lines

becomes

- my list item broken into multiple lines

Package

markdown.cl

Source

parser.lisp (file)

Function: make-image URL ALT TITLE
Package

markdown.cl

Source

parser.lisp (file)

Function: make-link URL TEXT TITLE
Package

markdown.cl

Source

parser.lisp (file)

Function: normalize-lists STR

Run bullets/lists through some normalization filters to make them easier to parse. Numbered lists are converted to +, regular bullets converted to -. This greatly simplifies parsing later on.

Package

markdown.cl

Source

parser.lisp (file)

Function: pad-string STR PADDING

There’s probably a lisp function for this already. Pads the beginning and end of the given string with the given padding (also a string).

Package

markdown.cl

Source

parser.lisp (file)

Function: paragraph-format STR

This function looks for {{markdown.cl|paragraph}} tags and splits up the text given accordingly, adding opening/closing markdown.cl paragraph tags around each of the splits. It then uses format-html-blocks-in-paragraph to remove any paragraph tags that shouldn’t be there.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-atx-headers STR

Parses ATX-style headers:

### This will be an h3 tag lol

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-blockquote STR

Parse a blockquote recursively, using the passed-in regex.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-br STR

Parse <br> tags (when a line ends with two spaces).

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-code STR

Parses code sections in markdown.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-em STR

Parse *, _, **, and __, but only in non-code blocks. It’s tricky though, because our <em>/<strong> elements must be able to span across <code> blocks. What we do it replace any * objects in <code> blocks with a meta string, process the em/strong tags, and then replace hte meta char. Works great.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-embedded-blockquote STR

Parse blockquotes that occur inside a list. This must be a separate step, otherwise things can get wonky when parsing lists. The idea is to find blockquotes that are embedded in lists *before* the lists are processed, then turn them into what the list parser views as a standard paragraph.

Instead of injecting embedded blockquotes directly into the list string, they are saved in a hash table and injected afterwards for more accurate parsing.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-embedded-code STR

Parses code that is embedded inside something else (a list, for instance). Generally, embedded code starts with 8 spaces instead of 4.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-entities STR

On top of parsing entities:

I am a sicko & a perv => I am a sicko &amp; a perv
Dogs > cats => Dogs &gt; cats
<em>I’m the best</em> => <em>I’m the best</em>

also escape the inside of <code> blocks:

<code><div>&copy;</div></code>

becomes:

<code>&lt;div&gt;&amp;copy;&lt;/div&gt;</code>

It does this using the parse-not-in-code function, which operates inside code blocks, using do-parse-entities outside code blocks, and escaping everything inside code blocks.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-escaped-characters STR

Parse characters that are escaped with \

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-horizontal-rule STR

Make horizontal rules. These are (almost?) always wrapped in <p> tags by the paragraph parser, but this is taken care of in the final parsing pass.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-inline-code STR

Parse ‘...‘ code blocks.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-links STR

Parse all link styles. It’s important to note that because the image/link syntax is so similar, the following parsers handle both images and links.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-links-ref STR

Parse links that are reference-style: [link text][id]

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-links-self STR

Parse links that are self contained (not a reference): [my link text](http://url.com "title")

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-list-blocks STR

This function takes a list block, and splits it into sub-blocks depending on list type (in other words, if a numbered list directly follows a normal list, the two are processed separately). This is done recursively.

It also detects the amount of intent the list uses, which it sends into ‘format-lists‘ when an entire block has been singled out.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-lists STR

Parse lists (both bullet and number lists). First, normalizes them (which makes them a whole lot easier to parse) then recursively parses them.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-not-in-code STR PARSER-FN &key ESCAPE IN-CODE-FN

Given a string and a parsing function, run the parsing function over the parts of the string that are not inside any code block.

Also has the ability to escape the internals of code blocks.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-paragraphs STR &key PRE-FORMATTED

This formats paragraphs in text. Most blocks given to is are treated as paragraph blocks until otherwise noted. If it detects that another parser added in paragraph tags, it will skip the block *unless* the pre-formatted key arg is T (meaning that the string being passed in has paragraph tags in it that need to be dealt with).

This function also does its best to clean the output by ridding us of empty paragraph blocks.

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-quick-links STR

Parse quick-link style: <http://killtheradio.net>

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-setext-headers STR

Parse setext headers:
This will be an h1 ==================

Package

markdown.cl

Source

parser.lisp (file)

Function: parse-table STR

Parse github format tables. Takes a string formated per the github version of markdown. It returns an html table if the block contains a pipe character and the second non-whitespace line in the block contains at least three consecutive dashes e.g. ’—’. Otherwise it returns the original string. See https://help.github.com/articles/organizing-information-with-tables/. The columns can be aligned right, center or left if colons are inserted on the sides of the hyphens within the header row. At the moment you cannot use a pipe as content within the cell.

Package

markdown.cl

Source

parser.lisp (file)

Function: post-process-markdown-html STR

This function does any needed cleanup to marry inline HTML and markdown.

Package

markdown.cl

Source

html.lisp (file)

Function: pre-format-paragraph-lists STR &optional JOIN-LIST-ITEMS

Format lists in paragraph style to be normalized so they aren’t chopped up by the rest of the parsing.

Package

markdown.cl

Source

parser.lisp (file)

Function: pre-process-markdown-html STR

This function performs any needed parsing on existing HTML of a markdown string.

Package

markdown.cl

Source

html.lisp (file)

Function: prepare-markdown-string STR

A lot of the regular expressions, in order to maintain simplicity, expect the strings they are given to be formatted in a certain way. For instance, instead of testing for (^|\n), if every string is started with a \n, then we can just test for \n (and leave out testing for the beginning of the string).

Package

markdown.cl

Source

parser.lisp (file)

Function: replace-html-blocks STR

Find any {{markdown.cl|htmlblock|...}} tags and replace them with their saved content.

Package

markdown.cl

Source

html.lisp (file)

Function: split-blocks STR

Splits a markdown document into a set of blocks, each block generally consisting of a certain type (list, blockquote, paragraph, etc).

Package

markdown.cl

Source

parser.lisp (file)

Function: stash-html-block-tags STR

Finds all top-level HTML block-level tags and saves them for later. Does so by incrementally searching for the next line starting with a block-level tag and using xmls to parse it, adding a placeholder in its stead. Inline elements are just added back into the parts array (not saved). This allows them to be markdown-processed. str is modified destructively as the loop progresses, making sure we don’t get stuck in endless loop finding the same tags over again.

Package

markdown.cl

Source

html.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   M  
Index Entry  Section

F
File, Lisp, markdown.cl.asd: The markdown<dot>cl<dot>asd file
File, Lisp, markdown.cl/html.lisp: The markdown<dot>cl/html<dot>lisp file
File, Lisp, markdown.cl/package.lisp: The markdown<dot>cl/package<dot>lisp file
File, Lisp, markdown.cl/parser.lisp: The markdown<dot>cl/parser<dot>lisp file
File, Lisp, markdown.cl/util.lisp: The markdown<dot>cl/util<dot>lisp file

L
Lisp File, markdown.cl.asd: The markdown<dot>cl<dot>asd file
Lisp File, markdown.cl/html.lisp: The markdown<dot>cl/html<dot>lisp file
Lisp File, markdown.cl/package.lisp: The markdown<dot>cl/package<dot>lisp file
Lisp File, markdown.cl/parser.lisp: The markdown<dot>cl/parser<dot>lisp file
Lisp File, markdown.cl/util.lisp: The markdown<dot>cl/util<dot>lisp file

M
markdown.cl.asd: The markdown<dot>cl<dot>asd file
markdown.cl/html.lisp: The markdown<dot>cl/html<dot>lisp file
markdown.cl/package.lisp: The markdown<dot>cl/package<dot>lisp file
markdown.cl/parser.lisp: The markdown<dot>cl/parser<dot>lisp file
markdown.cl/util.lisp: The markdown<dot>cl/util<dot>lisp file

Jump to:   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   B   C   D   E   F   G   I   J   M   N   P   R   S  
Index Entry  Section

B
block-element-p: Internal functions

C
cleanup-code: Internal functions
cleanup-escaped-characters: Internal functions
cleanup-hr: Internal functions
cleanup-markdown-tags: Internal functions
cleanup-newlines: Internal functions
cleanup-paragraphs: Internal functions
convert-lazy-blockquote-to-standard: Internal functions

D
do-parse-br: Internal functions
do-parse-code: Internal functions
do-parse-double-code: Internal functions
do-parse-em: Internal functions
do-parse-entities: Internal functions

E
escape-html: Internal functions
escape-html-entities: Internal functions
escape-links-href: Internal functions

F
file-contents: Internal functions
fix-a-tags: Internal functions
fix-inline-links: Internal functions
format-blockquote: Internal functions
format-code: Internal functions
format-html-blocks-in-paragraph: Internal functions
format-lists: Internal functions
Function, block-element-p: Internal functions
Function, cleanup-code: Internal functions
Function, cleanup-escaped-characters: Internal functions
Function, cleanup-hr: Internal functions
Function, cleanup-markdown-tags: Internal functions
Function, cleanup-newlines: Internal functions
Function, cleanup-paragraphs: Internal functions
Function, convert-lazy-blockquote-to-standard: Internal functions
Function, do-parse-br: Internal functions
Function, do-parse-code: Internal functions
Function, do-parse-double-code: Internal functions
Function, do-parse-em: Internal functions
Function, do-parse-entities: Internal functions
Function, escape-html: Internal functions
Function, escape-html-entities: Internal functions
Function, escape-links-href: Internal functions
Function, file-contents: Internal functions
Function, fix-a-tags: Internal functions
Function, fix-inline-links: Internal functions
Function, format-blockquote: Internal functions
Function, format-code: Internal functions
Function, format-html-blocks-in-paragraph: Internal functions
Function, format-lists: Internal functions
Function, gather-link-references: Internal functions
Function, inject-saved-blockquotes: Internal functions
Function, join-list-lines: Internal functions
Function, make-image: Internal functions
Function, make-link: Internal functions
Function, normalize-lists: Internal functions
Function, pad-string: Internal functions
Function, paragraph-format: Internal functions
Function, parse: Exported functions
Function, parse-atx-headers: Internal functions
Function, parse-blockquote: Internal functions
Function, parse-br: Internal functions
Function, parse-code: Internal functions
Function, parse-em: Internal functions
Function, parse-embedded-blockquote: Internal functions
Function, parse-embedded-code: Internal functions
Function, parse-entities: Internal functions
Function, parse-escaped-characters: Internal functions
Function, parse-file: Exported functions
Function, parse-horizontal-rule: Internal functions
Function, parse-inline-code: Internal functions
Function, parse-links: Internal functions
Function, parse-links-ref: Internal functions
Function, parse-links-self: Internal functions
Function, parse-list-blocks: Internal functions
Function, parse-lists: Internal functions
Function, parse-not-in-code: Internal functions
Function, parse-paragraphs: Internal functions
Function, parse-quick-links: Internal functions
Function, parse-setext-headers: Internal functions
Function, parse-table: Internal functions
Function, post-process-markdown-html: Internal functions
Function, pre-format-paragraph-lists: Internal functions
Function, pre-process-markdown-html: Internal functions
Function, prepare-markdown-string: Internal functions
Function, replace-html-blocks: Internal functions
Function, split-blocks: Internal functions
Function, stash-html-block-tags: Internal functions

G
gather-link-references: Internal functions

I
inject-saved-blockquotes: Internal functions

J
join-list-lines: Internal functions

M
make-image: Internal functions
make-link: Internal functions

N
normalize-lists: Internal functions

P
pad-string: Internal functions
paragraph-format: Internal functions
parse: Exported functions
parse-atx-headers: Internal functions
parse-blockquote: Internal functions
parse-br: Internal functions
parse-code: Internal functions
parse-em: Internal functions
parse-embedded-blockquote: Internal functions
parse-embedded-code: Internal functions
parse-entities: Internal functions
parse-escaped-characters: Internal functions
parse-file: Exported functions
parse-horizontal-rule: Internal functions
parse-inline-code: Internal functions
parse-links: Internal functions
parse-links-ref: Internal functions
parse-links-self: Internal functions
parse-list-blocks: Internal functions
parse-lists: Internal functions
parse-not-in-code: Internal functions
parse-paragraphs: Internal functions
parse-quick-links: Internal functions
parse-setext-headers: Internal functions
parse-table: Internal functions
post-process-markdown-html: Internal functions
pre-format-paragraph-lists: Internal functions
pre-process-markdown-html: Internal functions
prepare-markdown-string: Internal functions

R
replace-html-blocks: Internal functions

S
split-blocks: Internal functions
stash-html-block-tags: Internal functions

Jump to:   B   C   D   E   F   G   I   J   M   N   P   R   S  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
S  
Index Entry  Section

*
*block-level-elements*: Internal special variables
*html-chunks*: Internal special variables
*link-references*: Internal special variables
*list-recursion-level*: Internal special variables
*nl*: Internal special variables
*scanner-block-list-pos*: Internal special variables
*scanner-blockquote*: Internal special variables
*scanner-find-first-html-block-element*: Internal special variables
*scanner-find-last-html-block-element*: Internal special variables
*scanner-lazy-blockquote*: Internal special variables
*tmp-storage*: Internal special variables

S
Special Variable, *block-level-elements*: Internal special variables
Special Variable, *html-chunks*: Internal special variables
Special Variable, *link-references*: Internal special variables
Special Variable, *list-recursion-level*: Internal special variables
Special Variable, *nl*: Internal special variables
Special Variable, *scanner-block-list-pos*: Internal special variables
Special Variable, *scanner-blockquote*: Internal special variables
Special Variable, *scanner-find-first-html-block-element*: Internal special variables
Special Variable, *scanner-find-last-html-block-element*: Internal special variables
Special Variable, *scanner-lazy-blockquote*: Internal special variables
Special Variable, *tmp-storage*: Internal special variables

Jump to:   *  
S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   E   M   P   S  
Index Entry  Section

C
Condition, error-parsing-html: Exported conditions

E
error-parsing-html: Exported conditions

M
markdown.cl: The markdown<dot>cl system
markdown.cl: The markdown<dot>cl package

P
Package, markdown.cl: The markdown<dot>cl package

S
System, markdown.cl: The markdown<dot>cl system

Jump to:   C   E   M   P   S