cmark(3)

✨ cmark(3) ✨ — Library Functions Manual 💅

okay bestie, sit down, sip ur matcha 🍵, because this is the page for cmark, the library that does CommonMark parsing, manipulating, and rendering. it's a C library. it's giving main character energy. and you're gonna understand every single bit of it. no cap. 🫶

---

🌸 NAME 🌸

cmark — CommonMark parsing, manipulating, and rendering ✨

---

🎀 DESCRIPTION 🎀

💖 Simple Interface 💖

• char * cmark_markdown_to_html(const char *text, size_t len, int options)

this one is the glow-up button, fr fr. it takes text (which we assume is a UTF-8 encoded string, with length len) and converts it from CommonMark Markdown into HTML, handing you back a null-terminated, UTF-8-encoded string. 🦋

⚠️ bestie listen — it is the caller's responsibility to free the returned buffer. that memory is yours now. take care of it. 💀

🌈 Node Structure 🌈

here's the whole taxonomy of nodes, the family tree of the document, if you will:

typedef enum {
  /* Error status */
  CMARK_NODE_NONE,

  /* Block */
  CMARK_NODE_DOCUMENT,
  CMARK_NODE_BLOCK_QUOTE,
  CMARK_NODE_LIST,
  CMARK_NODE_ITEM,
  CMARK_NODE_CODE_BLOCK,
  CMARK_NODE_HTML_BLOCK,
  CMARK_NODE_CUSTOM_BLOCK,
  CMARK_NODE_PARAGRAPH,
  CMARK_NODE_HEADING,
  CMARK_NODE_THEMATIC_BREAK,

  CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT,
  CMARK_NODE_LAST_BLOCK = CMARK_NODE_THEMATIC_BREAK,

  /* Inline */
  CMARK_NODE_TEXT,
  CMARK_NODE_SOFTBREAK,
  CMARK_NODE_LINEBREAK,
  CMARK_NODE_CODE,
  CMARK_NODE_HTML_INLINE,
  CMARK_NODE_CUSTOM_INLINE,
  CMARK_NODE_EMPH,
  CMARK_NODE_STRONG,
  CMARK_NODE_LINK,
  CMARK_NODE_IMAGE,

  CMARK_NODE_FIRST_INLINE = CMARK_NODE_TEXT,
  CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE
} cmark_node_type;

and then the two lil side-enums that describe lists and their delimiters:

typedef enum {
  CMARK_NO_LIST,
  CMARK_BULLET_LIST,
  CMARK_ORDERED_LIST
} cmark_list_type;

typedef enum {
  CMARK_NO_DELIM,
  CMARK_PERIOD_DELIM,
  CMARK_PAREN_DELIM
} cmark_delim_type;

🧚 Custom memory allocator support 🧚

if you're the type of girlie who likes to control her own memory (respect 💜), here's the struct:

typedef struct cmark_mem {
  void *(*calloc)(size_t, size_t);
  void *(*realloc)(void *, size_t);
  void (*free)(void *);
} cmark_mem;

it defines the memory allocation functions to be used by CMark when parsing and allocating a document tree. 🎀

• cmark_mem * cmark_get_default_mem_allocator(void) — returns a pointer to the default memory allocator. easy. iconic. no notes. ✨

👑 Creating and Destroying Nodes 👑

• cmark_node * cmark_node_new(cmark_node_type type) — creates a new node of type type. heads up though: the node may have other required properties, and it's your job as the caller to assign them. don't leave it half-dressed bestie 🙈
• cmark_node * cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) — same as cmark_node_new, but it explicitly lists the memory allocator used to allocate the node. 📝

⚠️ note: be sure to use the same allocator for every node in a tree, or bad things can happen. we do not want the bad things. 😭

• void cmark_node_free(cmark_node *node) — frees the memory allocated for a node and any children. the whole bloodline. gone. 💅

🦋 Tree Traversal 🦋

• cmark_node * cmark_node_next(cmark_node *node) — returns the next node in the sequence after node, or NULL if there is none.
• cmark_node * cmark_node_previous(cmark_node *node) — returns the previous node in the sequence after node, or NULL if there is none.
• cmark_node * cmark_node_parent(cmark_node *node) — returns the parent of node, or NULL if there is none.
• cmark_node * cmark_node_first_child(cmark_node *node) — returns the first child of node, or NULL if node has no children.
• cmark_node * cmark_node_last_child(cmark_node *node) — returns the last child of node, or NULL if node has no children.

🎀 Iterator 🎀

okay so an iterator will walk through a tree of nodes, starting from a root node, returning one node at a time, together with info about whether the node is being entered or exited. 🚶♀️

the iterator will first descend to a child node, if there is one. when there is no child, the iterator will go to the next sibling. when there is no next sibling, the iterator will return to the parent — but with a cmark_event_type of CMARK_EVENT_EXIT. and it returns CMARK_EVENT_DONE when it reaches the root node again. 🌈

one natural application is an HTML renderer, where an ENTER event outputs an open tag and an EXIT event outputs a close tag. an iterator might also be used to transform an AST in some systematic way — for example, turning all level-3 headings into regular paragraphs. obsessed. 😌

void
usage_example(cmark_node *root) {
    cmark_event_type ev_type;
    cmark_iter *iter = cmark_iter_new(root);

    while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
        cmark_node *cur = cmark_iter_get_node(iter);
        // Do something with `cur` and `ev_type`
    }

    cmark_iter_free(iter);
}

⚠️ iterators will never return EXIT events for leaf nodes, which are nodes of type:

• CMARK_NODE_HTML_BLOCK
• CMARK_NODE_THEMATIC_BREAK
• CMARK_NODE_CODE_BLOCK
• CMARK_NODE_TEXT
• CMARK_NODE_SOFTBREAK
• CMARK_NODE_LINEBREAK
• CMARK_NODE_CODE
• CMARK_NODE_HTML_INLINE

🚨 and nodes must only be modified after an EXIT event, or an ENTER event for leaf nodes. that's the rule, bestie. don't test it. 💀

typedef enum {
  CMARK_EVENT_NONE,
  CMARK_EVENT_DONE,
  CMARK_EVENT_ENTER,
  CMARK_EVENT_EXIT
} cmark_event_type;

• cmark_iter * cmark_iter_new(cmark_node *root) — creates a new iterator starting at root. the current node and event type are undefined until cmark_iter_next is called for the first time. and you should release the memory allocated for the iterator using cmark_iter_free when you're done with it. ✨
• void cmark_iter_free(cmark_iter *iter) — frees the memory allocated for an iterator. bye girlie 👋
• cmark_event_type cmark_iter_next(cmark_iter *iter) — advances to the next node and returns the event type (CMARK_EVENT_ENTER, CMARK_EVENT_EXIT or CMARK_EVENT_DONE).
• cmark_node * cmark_iter_get_node(cmark_iter *iter) — returns the current node.
• cmark_event_type cmark_iter_get_event_type(cmark_iter *iter) — returns the current event type.
• cmark_node * cmark_iter_get_root(cmark_iter *iter) — returns the root node.
• void cmark_iter_reset(cmark_iter *iter, cmark_node *current, cmark_event_type event_type) — resets the iterator so that the current node is current and the event type is event_type. heads up: the new current node must be a descendant of the root node or the root node itself. no jumping ship 🛟

🫶 Accessors 🫶

these are the lil getters and setters, the whole gossip network of the tree 💬

• void * cmark_node_get_user_data(cmark_node *node) — returns the user data of node.
• int cmark_node_set_user_data(cmark_node *node, void *user_data) — sets arbitrary user data for node. returns 1 on success, 0 on failure.
• cmark_node_type cmark_node_get_type(cmark_node *node) — returns the type of node, or CMARK_NODE_NONE on error.
• const char * cmark_node_get_type_string(cmark_node *node) — like cmark_node_get_type, but returns a string representation of the type, or "<unknown>". 💅
• const char * cmark_node_get_literal(cmark_node *node) — returns the string contents of node, or an empty string if none is set. returns NULL if called on a node that does not have string content.
• int cmark_node_set_literal(cmark_node *node, const char *content) — sets the string contents of node. returns 1 on success, 0 on failure.
• int cmark_node_get_heading_level(cmark_node *node) — returns the heading level of node, or 0 if node is not a heading.
• int cmark_node_set_heading_level(cmark_node *node, int level) — sets the heading level of node, returning 1 on success and 0 on error.
• cmark_list_type cmark_node_get_list_type(cmark_node *node) — returns the list type of node, or CMARK_NO_LIST if node is not a list.
• int cmark_node_set_list_type(cmark_node *node, cmark_list_type type) — sets the list type of node, returning 1 on success and 0 on error.
• cmark_delim_type cmark_node_get_list_delim(cmark_node *node) — returns the list delimiter type of node, or CMARK_NO_DELIM if node is not a list.
• int cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim) — sets the list delimiter type of node, returning 1 on success and 0 on error.
• int cmark_node_get_list_start(cmark_node *node) — returns starting number of node, if it is an ordered list, otherwise 0.
• int cmark_node_set_list_start(cmark_node *node, int start) — sets starting number of node, if it is an ordered list. returns 1 on success, 0 on failure.
• int cmark_node_get_list_tight(cmark_node *node) — returns 1 if node is a tight list, 0 otherwise.
• int cmark_node_set_list_tight(cmark_node *node, int tight) — sets the "tightness" of a list. returns 1 on success, 0 on failure. the tightness bestie. the vibe check of lists. 🎀
• const char * cmark_node_get_fence_info(cmark_node *node) — returns the info string from a fenced code block.
• int cmark_node_set_fence_info(cmark_node *node, const char *info) — sets the info string in a fenced code block, returning 1 on success and 0 on failure.
• const char * cmark_node_get_url(cmark_node *node) — returns the URL of a link or image node, or an empty string if no URL is set. returns NULL if called on a node that is not a link or image.
• int cmark_node_set_url(cmark_node *node, const char *url) — sets the URL of a link or image node. returns 1 on success, 0 on failure.
• const char * cmark_node_get_title(cmark_node *node) — returns the title of a link or image node, or an empty string if no title is set. returns NULL if called on a node that is not a link or image.
• int cmark_node_set_title(cmark_node *node, const char *title) — sets the title of a link or image node. returns 1 on success, 0 on failure.
• const char * cmark_node_get_on_enter(cmark_node *node) — returns the literal "on enter" text for a custom node, or an empty string if no on_enter is set. returns NULL if called on a non-custom node.
• int cmark_node_set_on_enter(cmark_node *node, const char *on_enter) — sets the literal text to render "on enter" for a custom node. any children of the node will be rendered after this text. returns 1 on success 0 on failure.
• const char * cmark_node_get_on_exit(cmark_node *node) — returns the literal "on exit" text for a custom node, or an empty string if no on_exit is set. returns NULL if called on a non-custom node.
• int cmark_node_set_on_exit(cmark_node *node, const char *on_exit) — sets the literal text to render "on exit" for a custom node. any children of the node will be rendered before this text. returns 1 on success 0 on failure.
• int cmark_node_get_start_line(cmark_node *node) — returns the line on which node begins. 📍
• int cmark_node_get_start_column(cmark_node *node) — returns the column at which node begins.
• int cmark_node_get_end_line(cmark_node *node) — returns the line on which node ends.
• int cmark_node_get_end_column(cmark_node *node) — returns the column at which node ends.

🌟 Tree Manipulation 🌟

• void cmark_node_unlink(cmark_node *node) — unlinks a node, removing it from the tree, but not freeing its memory. (use cmark_node_free for that, bestie — they're two different jobs 💅)
• int cmark_node_insert_before(cmark_node *node, cmark_node *sibling) — inserts sibling before node. returns 1 on success, 0 on failure.
• int cmark_node_insert_after(cmark_node *node, cmark_node *sibling)

Inserts a sibling after node. Returns 1 on success, 0 on failure. 💅

• int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode) — Replaces oldnode with newnode and unlinks oldnode (but does not free its memory). Returns 1 on success, 0 on failure. 🫶
• int cmark_node_prepend_child(cmark_node *node, cmark_node *child) — Adds child to the beginning of the children of node. Returns 1 on success, 0 on failure. ✨
• int cmark_node_append_child(cmark_node *node, cmark_node *child) — Adds child to the end of the children of node. Returns 1 on success, 0 on failure. 💖
• void cmark_consolidate_text_nodes(cmark_node *root) — Consolidates adjacent text nodes. 🧚

---

Parsing ✨

Simple interface, bestie:

cmark_node *document = cmark_parse_document("Hello *world*", 13,
                                            CMARK_OPT_DEFAULT);

Streaming interface, for when you're feeding it bits at a time:

cmark_parser *parser = cmark_parser_new(CMARK_OPT_DEFAULT);
FILE *fp = fopen("myfile.md", "rb");
while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
    cmark_parser_feed(parser, buffer, bytes);
    if (bytes < sizeof(buffer)) {
        break;
    }
}
document = cmark_parser_finish(parser);
cmark_parser_free(parser);

• cmark_parser * cmark_parser_new(int options) — Creates a new parser object. 🌸
• cmark_parser * cmark_parser_new_with_mem(int options, cmark_mem *mem) — Creates a new parser object with the given memory allocator. 💜

A generalization of cmark_parser_new:

cmark_parser_new(options)

is the same as:

cmark_parser_new_with_mem(options, cmark_get_default_mem_allocator())

• cmark_parser * cmark_parser_new_with_mem_into_root(int options, cmark_mem *mem, cmark_node *root) — Creates a new parser object with the given node to use as the root node of the parsed AST. 🌈

When parsing, children are always appended, not prepended; that means if root already has children, the newly-parsed children will appear after the given children. 👑

A generalization of cmark_parser_new_with_mem:

cmark_parser_new_with_mem(options, mem)

is approximately the same as:

cmark_parser_new_with_mem_into_root(options, mem, cmark_node_new(CMARK_NODE_DOCUMENT))

This is useful for creating a single document out of multiple parsed document fragments. 💅

• void cmark_parser_free(cmark_parser *parser) — Frees memory allocated for a parser object. 🫶
• void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len) — Feeds a string of length len to parser. ✨
• cmark_node * cmark_parser_finish(cmark_parser *parser) — Finish parsing and return a pointer to a tree of nodes. 💖
• cmark_node * cmark_parse_document(const char *buffer, size_t len, int options) — Parse a CommonMark document in buffer of length len. Returns a pointer to a tree of nodes. The memory allocated for the node tree should be released using cmark_node_free when it is no longer needed. 🧚
• cmark_node * cmark_parse_file(FILE *f, int options) — Parse a CommonMark document in file f, returning a pointer to a tree of nodes. The memory allocated for the node tree should be released using cmark_node_free when it is no longer needed. 🌸

---

Rendering 💜

• char * cmark_render_xml(cmark_node *root, int options) — Render a node tree as XML. It is the caller's responsibility to free the returned buffer. 💜
• char * cmark_render_html(cmark_node *root, int options) — Render a node tree as an HTML fragment. It is up to the user to add an appropriate header and footer. It is the caller's responsibility to free the returned buffer. 🌈
• char * cmark_render_man(cmark_node *root, int options, int width) — Render a node tree as a groff man page, without the header. It is the caller's responsibility to free the returned buffer. 👑
• char * cmark_render_commonmark(cmark_node *root, int options, int width) — Render a node tree as a commonmark document. It is the caller's responsibility to free the returned buffer. 💅
• char * cmark_render_latex(cmark_node *root, int options, int width) — Render a node tree as a LaTeX document. It is the caller's responsibility to free the returned buffer. 🫶

---

Options ✨

• #define CMARK_OPT_DEFAULT 0 — Default options. ✨

Options affecting rendering 💖

• #define CMARK_OPT_SOURCEPOS (1 << 1) — Include a data-sourcepos attribute on all block elements. 💖
• #define CMARK_OPT_HARDBREAKS (1 << 2) — Render softbreak elements as hard line breaks. 🧚
• #define CMARK_OPT_SAFE (1 << 3) — CMARK_OPT_SAFE is defined here for API compatibility, but it no longer has any effect. "Safe" mode is now the default: set CMARK_OPT_UNSAFE to disable it. 🌸
• #define CMARK_OPT_UNSAFE (1 << 17) — Render raw HTML and unsafe links (javascript:, vbscript:, file:, and data:, except for image/png, image/gif, image/jpeg, or image/webp mime types). By default, raw HTML is replaced by a placeholder HTML comment. Unsafe links are replaced by empty strings. 💜
• #define CMARK_OPT_NOBREAKS (1 << 4) — Render softbreak elements as spaces. 🌈

Options affecting parsing 👑

• #define CMARK_OPT_NORMALIZE (1 << 8) — Legacy option (no effect). 👑
• #define CMARK_OPT_VALIDATE_UTF8 (1 << 9) — Validate UTF-8 in the input before parsing, replacing illegal sequences with the replacement character U+FFFD. 💅
• #define CMARK_OPT_SMART (1 << 10) — Convert straight quotes to curly, --- to em dashes, -- to en dashes. 🫶

---

Version information 🌈

• int cmark_version(void) — The library version as integer for runtime checks. Also available as macro CMARK_VERSION for compile time checks. ✨
  • Bits 16-23 contain the major version. 💖
  • Bits 8-15 contain the minor version. 🧚
  • Bits 0-7 contain the patchlevel. 🌸

In hexadecimal format, the number 0x010203 represents version 1.2.3. 💜

• const char * cmark_version_string(void) — The library version string for runtime checks. Also available as macro CMARK_VERSION_STRING for compile time checks. 🌈

---

AUTHORS 👑

John MacFarlane, Vicent Marti, Kārlis Gaņģis, Nick Wellnhofer. 👑

---

That's the whole vibe from cmark 0.31.1, dated August 03, 2024, page cmark(3). Periodt. 💅✨