vendor/commonmark package | Odin Programming Language

Bindings for [[ CMark; https://github.com/commonmark/cmark ]]. Original authors: John MacFarlane, Vicent Marti, Kārlis Gaņģis, Nick Wellnhofer. See LICENSE for license details. Example: import cm "vendor:commonmark" // Parsing - Simple interface hellope_world :: proc() { fmt.printf("CMark version: %v\n", cm.version_string()) str := "Hellope *world*!" root := cm.parse_document(raw_data(str), len(str), cm.DEFAULT_OPTIONS) defer cm.node_free(root) html := cm.render_html(root, cm.DEFAULT_OPTIONS) defer cm.free(html) fmt.println(html) } // Parsing - Streaming interface streaming :: proc() { using cm STR :: "Hellope *world*!\n\n" N :: 50 STREAM_SIZE :: 42 str_buf: [len(STR) * N]u8 for i in 0..<N { copy(str_buf[i*len(STR):], STR) } parser := parser_new(DEFAULT_OPTIONS) defer parser_free(parser) buf := str_buf[:] for len(buf) > STREAM_SIZE { parser_feed(parser, raw_data(buf), STREAM_SIZE) buf = buf[STREAM_SIZE:] } if len(buf) > 0 { parser_feed(parser, raw_data(buf), len(buf)) buf = buf[len(buf):] } root := parser_finish(parser) defer cm.node_free(root) html := cm.render_html(root, cm.DEFAULT_OPTIONS) defer cm.free(html) fmt.println(html) } An iterator will walk through a tree of nodes, starting from a root node, returning one node at a time, together with information 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 an `Event_Type.Exit`). The iterator will return `.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. usage_example(root: ^Node) { ev_type: Event_Type iter := iter_new(root) defer iter_free(iter) for { ev_type = iter_next(iter) if ev_type == .Done do break cur := iter_get_node(iter) // Do something with `cur` and `ev_type` } } Iterators will never return `.Exit` events for leaf nodes, which are nodes of type: HTML_Block Thematic_Break Code_Block Text Soft_Break Line_Break Code HTML_Inline Nodes must only be modified after an `.Exit` event, or an `.Enter` event for leaf nodes.

Collection Info

Collection: vendor
Path: commonmark
Entries: 99

Source Files

Constants

3

BINDING_VERSION #

BINDING_VERSION :: Version_Info{major = 0, minor = 30, patch = 2}

COMMONMARK_SHARED #

COMMONMARK_SHARED :: #config(COMMONMARK_SHARED, false)

DEFAULT_OPTIONS #

DEFAULT_OPTIONS :: Options{}

Config Values

1

COMMONMARK_SHARED #

COMMONMARK_SHARED :: #config(COMMONMARK_SHARED, false)

Types

19

Allocator #

Allocator :: Allocator

Custom allocator - Defines the memory allocation functions to be used by CMark when parsing and allocating a document tree

bufsize_t #

bufsize_t :: distinct bufsize_t

Code #

Code :: Code

Custom #

Custom :: Custom

Delim_Type #

Delim_Type :: Delim_Type

Event_Type #

Event_Type :: Event_Type

Heading #

Heading :: Heading

Iter #

Iter :: distinct Iter

Link #

Link :: Link

List #

List :: List

List_Type #

List_Type :: List_Type

Node #

Node :: Node

Node creation, destruction, and tree traversal

Node_Flag #

Node_Flag :: Node_Flag

Node_Flags #

Node_Flags :: bit_set[Node_Flag]

Node_Type #

Node_Type :: Node_Type

Option #

Option :: Option

Options #

Options :: bit_set[Option]

Parser #

Parser :: distinct Parser

Version_Info #

Version_Info :: Version_Info

Version information

Procedures

75

consolidate_text_nodes #

consolidate_text_nodes :: proc "c" (root: ^Node) ---

Consolidates adjacent text nodes.

free_cstring #

free_cstring :: proc "c" (str: cstring) {…}

free_rawptr #

free_rawptr :: proc "c" (ptr: rawptr) {…}

Helpers to free results from `render_*`.

free_string #

free_string :: proc "c" (s: string) {…}

get_default_mem_allocator #

get_default_mem_allocator :: proc "c" () -> (mem: ^Allocator) ---

Returns a pointer to the default memory allocator.

get_default_mem_allocator_as_odin #

get_default_mem_allocator_as_odin :: proc() -> Allocator {…}

iter_free #

iter_free :: proc "c" (iter: ^Iter) ---

Frees the memory allocated for an iterator.

iter_get_event_type #

iter_get_event_type :: proc "c" (iter: ^Iter) -> (event_type: Event_Type) ---

Returns the current event type.

iter_get_node #

iter_get_node :: proc "c" (iter: ^Iter) -> (node: ^Node) ---

Returns the current node.

iter_get_root #

iter_get_root :: proc "c" (iter: ^Iter) -> (root: ^Node) ---

Returns the root node.

iter_new #

iter_new :: proc "c" (root: ^Node) -> (iter: ^Iter) ---

Creates a new iterator starting at 'root'. The current node and event type are undefined until `iter_next` is called for the first time. The memory allocated for the iterator should be released using 'iter_free' when it is no longer needed.

iter_next #

iter_next :: proc "c" (iter: ^Iter) -> (event_type: Event_Type) ---

Advances to the next node and returns the event type (`.Enter`, `.Exit`, `.Done`)

iter_reset #

iter_reset :: proc "c" (iter: ^Iter, current: ^Node, event_type: Event_Type) ---

Resets the iterator so that the current node is `current` and the event type is `event_type`. The new current node must be a descendant of the root node or the root node itself.

markdown_to_html #

markdown_to_html :: proc "c" (text: cstring, length: uint, options: bit_set[Option]) -> (html: cstring) ---

Convert 'text' (assumed to be a UTF-8 encoded string with length `len`) from CommonMark Markdown to HTML returning a null-terminated, UTF-8-encoded string. It is the caller's responsibility to free the returned buffer.

markdown_to_html_from_string #

markdown_to_html_from_string :: proc(text: string, options: bit_set[Option]) -> (html: string) {…}

node_append_child #

node_append_child :: proc "c" (node: ^Node, child: ^Node) -> (success: b32) ---

Adds 'child' to the end of the children of `node`. Returns `true` on success, `false` on failure.

node_first_child #

node_first_child :: proc "c" (node: ^Node) -> (child: ^Node) ---

Returns the first child of `node`, or nil if `node` has no children.

node_free #

node_free :: proc "c" (node: ^Node) ---

Frees the memory allocated for a node and any children.

node_get_end_column #

node_get_end_column :: proc "c" (node: ^Node) -> (column: i32) ---

Returns the column at which `node` ends.

node_get_end_line #

node_get_end_line :: proc "c" (node: ^Node) -> (line: i32) ---

Returns the line on which `node` ends.

node_get_fence_info #

node_get_fence_info :: proc "c" (node: ^Node) -> (fence_info: cstring) ---

Returns the info string from a fenced code block.

node_get_heading_level #

node_get_heading_level :: proc "c" (node: ^Node) -> (level: i32) ---

Returns the heading level of `node`, or 0 if `node` is not a heading.

node_get_list_delim #

node_get_list_delim :: proc "c" (node: ^Node) -> (delim_type: Delim_Type) ---

Returns the list delimiter type of `node`, or `.No_Delim` if not a list.

node_get_list_start #

node_get_list_start :: proc "c" (node: ^Node) -> (start: i32) ---

Returns starting number of `node`, if it is an ordered list, otherwise 0.

node_get_list_tight #

node_get_list_tight :: proc "c" (node: ^Node) -> (tight: b32) ---

Returns `true` if `node` is a tight list, `false` otherwise.

node_get_list_type #

node_get_list_type :: proc "c" (node: ^Node) -> (list_type: List_Type) ---

Returns the list type of `node`, or `.No_List` if not a list.

node_get_literal #

node_get_literal :: proc "c" (node: ^Node) -> (content: cstring) ---

Returns the string contents of `node`, or an empty string if none is set. Returns `nil` if called on a node that does not have string content.

node_get_on_enter #

node_get_on_enter :: proc "c" (node: ^Node) -> (on_enter: cstring) ---

Returns the literal "on enter" text for a custom `node`, or an empty string if no on_enter is set. Returns nil if called on a non-custom node.

node_get_on_exit #

node_get_on_exit :: proc "c" (node: ^Node) -> (on_exit: cstring) ---

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.

node_get_start_column #

node_get_start_column :: proc "c" (node: ^Node) -> (column: i32) ---

Returns the column at which `node` begins.

node_get_start_line #

node_get_start_line :: proc "c" (node: ^Node) -> (line: i32) ---

Returns the line on which `node` begins.

node_get_title #

node_get_title :: proc "c" (node: ^Node) -> (title: cstring) ---

Returns the title of a link or image `node`, or an empty string if no title is set. Returns nil if called on a node that is not a link or image.

node_get_type #

node_get_type :: proc "c" (node: ^Node) -> (node_type: Node_Type) ---

Returns the type of `node`, or `.None` on error.

node_get_type_string #

node_get_type_string :: proc "c" (node: ^Node) -> (node_type: cstring) ---

Like `node_get_type`, but returns a string representation of the type, or "<unknown>".

node_get_url #

node_get_url :: proc "c" (node: ^Node) -> (url: cstring) ---

Returns the URL of a link or image `node`, or an empty string if no URL is set. Returns nil if called on a node that is not a link or image.

node_get_user_data #

node_get_user_data :: proc "c" (node: ^Node) -> (user_data: rawptr) ---

Returns the user data of `node`.

node_insert_after #

node_insert_after :: proc "c" (node: ^Node, sibling: ^Node) -> (success: b32) ---

Inserts 'sibling' after `node`. Returns `true` on success, `false` on failure.

node_insert_before #

node_insert_before :: proc "c" (node: ^Node, sibling: ^Node) -> (success: b32) ---

Inserts 'sibling' before `node`. Returns `true` on success, `false` on failure.

node_last_child #

node_last_child :: proc "c" (node: ^Node) -> (child: ^Node) ---

Returns the last child of `node`, or nil if `node` has no children.

node_new #

node_new :: proc "c" (type: Node_Type) -> (node: ^Node) ---

Creates a new node of type 'type'. Note that the node may have other required properties, which it is the caller's responsibility to assign.

node_new_with_mem #

node_new_with_mem :: proc "c" (type: Node_Type, mem: ^Allocator) -> (node: ^Node) ---

Same as `node_new`, but explicitly listing 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.

node_next #

node_next :: proc "c" (node: ^Node) -> (next: ^Node) ---

Tree Traversal Returns the next node in the sequence after `node`, or nil if there is none.

node_parent #

node_parent :: proc "c" (node: ^Node) -> (parent: ^Node) ---

Returns the parent of `node`, or nil if there is none.

node_prepend_child #

node_prepend_child :: proc "c" (node: ^Node, child: ^Node) -> (success: b32) ---

Adds 'child' to the beginning of the children of `node`. Returns `true` on success, `false` on failure.

node_previous #

node_previous :: proc "c" (node: ^Node) -> (prev: ^Node) ---

Returns the previous node in the sequence after `node`, or nil if there is none.

node_replace #

node_replace :: proc "c" (old_node: ^Node, new_node: ^Node) -> (success: b32) ---

Replaces 'oldnode' with 'newnode' and unlinks 'oldnode' (but does not free its memory). Returns `true` on success, `false` on failure.

node_set_fence_info #

node_set_fence_info :: proc "c" (node: ^Node, fence_info: cstring) -> (success: b32) ---

Sets the info string in a fenced code block, returning `true` on success and `false` on failure.

node_set_heading_level #

node_set_heading_level :: proc "c" (node: ^Node, level: i32) -> (success: b32) ---

Sets the heading level of `node`. Returns `true` on success, `false` on failure.

node_set_list_delim #

node_set_list_delim :: proc "c" (node: ^Node, delim_type: Delim_Type) -> (success: b32) ---

Sets the delimiter type of `node`. Returns `true` on success, `false` on failure.

node_set_list_start #

node_set_list_start :: proc "c" (node: ^Node, start: i32) -> (success: b32) ---

Sets starting number of `node`, if it is an ordered list. Returns `true` on success, `false` on failure.

node_set_list_tight #

node_set_list_tight :: proc "c" (node: ^Node, tight: b32) -> (success: b32) ---

Sets the "tightness" of a list. Returns `true` on success, `false` on failure.

node_set_list_type #

node_set_list_type :: proc "c" (node: ^Node, list_type: List_Type) -> (success: b32) ---

Sets the list type of `node`. Returns `true` on success, `false` on failure.

node_set_literal #

node_set_literal :: proc "c" (node: ^Node, content: cstring) -> (success: b32) ---

Sets the string contents of `node`. Returns `true` on success, `false` on failure.

node_set_on_enter #

node_set_on_enter :: proc "c" (node: ^Node, on_enter: cstring) -> (success: b32) ---

Sets the literal text to render "on enter" for a custom `node`. Any children of the node will be rendered after this text. Returns `true` on success, `false`on failure.

node_set_on_exit #

node_set_on_exit :: proc "c" (node: ^Node, on_exit: cstring) -> (success: b32) ---

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.

node_set_title #

node_set_title :: proc "c" (node: ^Node, title: cstring) -> (success: b32) ---

Sets the title of a link or image `node`. Returns `true` on success, `false` on failure.

node_set_url #

node_set_url :: proc "c" (node: ^Node, url: cstring) -> (success: b32) ---

Sets the URL of a link or image `node`. Returns `true` on success, `false` on failure.

node_set_user_data #

node_set_user_data :: proc "c" (node: ^Node, user_data: rawptr) -> (success: b32) ---

Sets arbitrary user data for `node`. Returns `true` on success, `false` on failure.

node_unlink #

node_unlink :: proc "c" (node: ^Node) ---

Unlinks a `node`, removing it from the tree, but not freeing its memory. (Use `node_free` for that.)

parse_document #

parse_document :: proc "c" (buffer: [^]u8, len: uint, options: bit_set[Option]) -> (root: ^Node) ---

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 'node_free' when it is no longer needed.

parse_document_from_string #

parse_document_from_string :: proc "c" (s: string, options: bit_set[Option]) -> (root: ^Node) {…}

parse_from_libc_file #

@(link_name="parse_from_file")

parse_from_libc_file :: proc "c" (file: ^FILE, options: bit_set[Option]) -> (root: ^Node) ---

parser_feed #

parser_feed :: proc "c" (parser: ^Parser, buffer: [^]u8, len: uint) ---

Feeds a string of length 'len' to 'parser'.

parser_feed_from_string #

parser_feed_from_string :: proc "c" (parser: ^Parser, s: string) {…}

parser_finish #

parser_finish :: proc "c" (parser: ^Parser) -> (root: ^Node) ---

Finish parsing and return a pointer to a tree of nodes.

parser_free #

parser_free :: proc "c" (parser: ^Parser) ---

Frees memory allocated for a parser object.

parser_new #

parser_new :: proc "c" (options: bit_set[Option]) -> (parser: ^Parser) ---

Creates a new parser object.

parser_new_with_mem #

parser_new_with_mem :: proc "c" (options: bit_set[Option], mem: ^Allocator) -> (parser: ^Parser) ---

Creates a new parser object with the given memory allocator.

render_commonmark #

render_commonmark :: proc "c" (root: ^Node, options: bit_set[Option], width: i32) -> (commonmark: cstring) ---

Render a `node` tree as a commonmark document. It is the caller's responsibility to free the returned buffer.

render_html #

render_html :: proc "c" (root: ^Node, options: bit_set[Option]) -> (html: cstring) ---

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.

render_latex #

render_latex :: proc "c" (root: ^Node, options: bit_set[Option], width: i32) -> (latex: cstring) ---

Render a `node` tree as a LaTeX document. It is the caller's responsibility to free the returned buffer.

render_man #

render_man :: proc "c" (root: ^Node, options: bit_set[Option], width: i32) -> (groff: cstring) ---

Render a `node` tree as a groff man page, without the header. It is the caller's responsibility to free the returned buffer.

render_xml #

render_xml :: proc "c" (root: ^Node, options: bit_set[Option]) -> (xml: cstring) ---

Render a `node` tree as XML. It is the caller's responsibilityto free the returned buffer.

version #

version :: proc "c" () -> (res: Version_Info) ---

version_string #

version_string :: proc "c" () -> (res: cstring) ---

Procedure Groups

1

free #

free :: proc{
	free_rawptr,
	free_cstring,
}