Merge pull request #1989 from Kelimion/cmarkdev-2022-09

Add CMark bindings

1 files changed, 526 insertions, 0 deletions

diff --git a/vendor/commonmark/cmark.odin b/vendor/commonmark/cmark.odin
new file mode 100644
index 000000000..313435870
--- /dev/null
+++ b/vendor/commonmark/cmark.odin
@@ -0,0 +1,526 @@
+/*
+	Bindings against CMark (https://github.com/commonmark/cmark)
+
+	Original authors: John MacFarlane, Vicent Marti, Kārlis Gaņģis, Nick Wellnhofer.
+	See LICENSE for license details.
+*/
+package commonmark
+
+import "core:c"
+import "core:c/libc"
+import "core:runtime"
+
+BINDING_VERSION :: Version_Info{major = 0, minor = 30, patch = 2}
+
+when ODIN_OS == .Windows {
+	foreign import lib {
+		"cmark_static.lib",
+	}
+} else when ODIN_OS == .Linux {
+	foreign import lib {
+		"libcmark.a",
+	}
+}
+
+Option :: enum c.int {
+	Source_Position =  1, // Include a `data-sourcepos` attribute on all block elements.
+	Hard_Breaks     =  2, // Render `softbreak` as hard line breaks.
+	Safe            =  3, // Defined for API compatibility, now enabled by default.
+	Unsafe          = 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.
+	No_Breaks       =  4, // Render `softbreak` elements as spaces.
+	Normalize       =  8, // Legacy option, no effect.
+	Validate_UTF8   =  9, // Validate UTF-8 input before parsing, replacing illegal
+						  // sequences with the replacement character U+FFFD.
+	Smart           = 10, // Convert straight quotes to curly, --- to em dashes, -- to en dashes.
+}
+Options :: bit_set[Option; c.int]
+
+DEFAULT_OPTIONS :: Options{}
+
+Node_Type :: enum u16 {
+	// Error status
+	None = 0,
+
+	/* Block */
+	Document,
+	Block_Quote,
+	List,
+	Item,
+	Code_Block,
+	HTML_Block,
+	Custom_Block,
+	Paragraph,
+	Heading,
+	Thematic_Break,
+
+	/* Inline */
+	Text,
+	Soft_Break,
+	Line_Break,
+	Code,
+	HTML_Inline,
+	Custom_Inline,
+	Emph,
+	Strong,
+	Link,
+	Image,
+
+	First_Block  = Document,
+	Last_Block   = Thematic_Break,
+
+	First_Inline = Text,
+	Last_Inline  = Image,
+}
+
+List_Type :: enum c.int {
+	None,
+	Bullet,
+	Ordered,
+}
+
+Delim_Type :: enum c.int {
+	None,
+	Period,
+	Paren,
+}
+
+// Version information
+Version_Info :: struct {
+	patch: u8,
+	minor: u8,
+	major: u8,
+	_:     u8,
+}
+
+@(default_calling_convention="c", link_prefix="cmark_")
+foreign lib {
+	version        :: proc() -> (res: Version_Info) ---
+	version_string :: proc() -> (res: cstring) ---
+}
+
+// Simple API
+@(default_calling_convention="c", link_prefix="cmark_")
+foreign lib {
+	// 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 :: proc(text: cstring, length: c.size_t, options: Options) -> (html: cstring) ---
+}
+
+markdown_to_html_from_string :: proc(text: string, options: Options) -> (html: string) {
+	return string(markdown_to_html(cstring(raw_data(text)), len(text), options))
+}
+
+// Custom allocator - Defines the memory allocation functions to be used by CMark
+// when parsing and allocating a document tree
+Allocator :: struct {
+	calloc:  proc "c" (num: c.size_t, size: c.size_t)  -> rawptr,
+	realloc: proc "c" (ptr: rawptr, new_size: c.size_t) -> rawptr,
+	free:    proc "c" (ptr: rawptr),
+}
+
+@(default_calling_convention="c", link_prefix="cmark_")
+foreign lib {
+	// Returns a pointer to the default memory allocator.
+	get_default_mem_allocator :: proc() -> (mem: ^Allocator) ---
+}
+
+bufsize_t :: distinct i32
+
+// Node creation, destruction, and tree traversal
+Node :: struct {
+	mem:          ^Allocator,
+
+	next:         ^Node,
+	prev:         ^Node,
+	parent:       ^Node,
+	first_child:  ^Node,
+	last_child:   ^Node,
+
+	user_data:    rawptr,
+	data:         [^]u8,
+	len:          bufsize_t,
+
+	start_line:   c.int,
+	start_column: c.int,
+	end_line:     c.int,
+	end_column:   c.int,
+
+	type:         Node_Type,
+	flags:        Node_Flags,
+
+	as: struct #raw_union {
+		list:    List,
+		code:    Code,
+		heading: Heading,
+		link:    Link,
+		custom:  Custom,
+		html_block_type: c.int,
+	},
+}
+
+Node_Flag :: enum u16 {
+	Open              = 0,
+	Last_Line_Blank   = 1,
+	Last_Line_Checked = 2,
+}
+Node_Flags :: bit_set[Node_Flag; u16]
+
+List :: struct {
+	marker_offset: c.int,
+	padding:       c.int,
+	start:         c.int,
+	list_type:     u8,
+	delimiter:     u8,
+	bullet_char:   u8,
+	tight:         c.bool,
+}
+
+Code :: struct {
+	info:         cstring,
+	fence_length: u8,
+	fence_offset: u8,
+	fence_char:   u8,
+	fenced:       b8,
+}
+
+Heading :: struct {
+	internal_offset: c.int,
+	level:           i8,
+	setext:          c.bool,
+}
+
+
+Link :: struct {
+	url:   cstring,
+	title: cstring,
+}
+
+Custom :: struct {
+	on_enter: cstring,
+	on_exit:  cstring,
+}
+
+@(default_calling_convention="c", link_prefix="cmark_")
+foreign lib {
+	// 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 :: proc(type: Node_Type) -> (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_new_with_mem :: proc(type: Node_Type, mem: ^Allocator) -> (node: ^Node) ---
+
+	// Frees the memory allocated for a node and any children.
+	node_free :: proc(node: ^Node) ---
+
+	/*
+		Tree Traversal
+	*/
+	// Returns the next node in the sequence after `node`, or nil if there is none.
+	node_next :: proc(node: ^Node) -> (next: ^Node) ---
+
+	// Returns the previous node in the sequence after `node`, or nil if there is none.
+	node_previous :: proc(node: ^Node) -> (prev: ^Node) ---
+
+	// Returns the parent of `node`, or nil if there is none.
+	node_parent :: proc(node: ^Node) -> (parent: ^Node) ---
+
+	// Returns the first child of `node`, or nil if `node` has no children.
+	node_first_child :: proc(node: ^Node) -> (child: ^Node) ---
+
+	// Returns the last child of `node`, or nil if `node` has no children.
+	node_last_child :: proc(node: ^Node) -> (child: ^Node) ---
+
+}
+
+Iter   :: distinct rawptr
+
+Event_Type :: enum c.int {
+	None,
+	Done,
+	Enter,
+	Exit,
+}
+
+@(default_calling_convention="c", link_prefix="cmark_")
+foreign lib {
+	// 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_new :: proc(root: ^Node) -> (iter: ^Iter) ---
+
+	// Frees the memory allocated for an iterator.
+	iter_free :: proc(iter: ^Iter) ---
+
+	// Advances to the next node and returns the event type (`.Enter`, `.Exit`, `.Done`)
+	iter_next :: proc(iter: ^Iter) -> (event_type: Event_Type) ---
+
+	// Returns the current node.
+	iter_get_node :: proc(iter: ^Iter) -> (node: ^Node) ---
+
+	// Returns the current event type.
+	iter_get_event_type :: proc(iter: ^Iter) -> (event_type: Event_Type) ---
+
+	// Returns the root node.
+	iter_get_root :: proc(iter: ^Iter) -> (root: ^Node) ---
+
+	// 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.
+	iter_reset :: proc(iter: ^Iter, current: ^Node, event_type: Event_Type) ---
+}
+
+// Accessors
+@(default_calling_convention="c", link_prefix="cmark_")
+foreign lib {
+	// Returns the user data of `node`.
+	node_get_user_data :: proc(node: ^Node) -> (user_data: rawptr) ---
+
+	// Sets arbitrary user data for `node`. Returns `true` on success, `false` on failure.
+	node_set_user_data :: proc(node: ^Node, user_data: rawptr) -> (success: b32) ---
+
+	// Returns the type of `node`, or `.None` on error.
+	node_get_type :: proc(node: ^Node) -> (node_type: Node_Type) ---
+
+	// Like `node_get_type`, but returns a string representation of the type, or "<unknown>".
+	node_get_type_string :: proc(node: ^Node) -> (node_type: 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_literal :: proc(node: ^Node) -> (content: cstring) ---
+
+	// Sets the string contents of `node`. Returns `true` on success, `false` on failure.
+	node_set_literal :: proc(node: ^Node, content: cstring) -> (success: b32) ---
+
+	// Returns the heading level of `node`, or 0 if `node` is not a heading.
+	node_get_heading_level :: proc(node: ^Node) -> (level: c.int) ---
+
+	// Sets the heading level of `node`. Returns `true` on success, `false` on failure.
+	node_set_heading_level :: proc(node: ^Node, level: c.int) -> (success: b32) ---
+
+	// Returns the list type of `node`, or `.No_List` if not a list.
+	node_get_list_type :: proc(node: ^Node) -> (list_type: List_Type) ---
+
+	// Sets the list type of `node`. Returns `true` on success, `false` on failure.
+	node_set_list_type :: proc(node: ^Node, list_type: List_Type) -> (success: b32) ---
+
+	// Returns the list delimiter type of `node`, or `.No_Delim` if not a list.
+	node_get_list_delim :: proc(node: ^Node) -> (delim_type: Delim_Type) ---
+
+	// Sets the delimiter type of `node`. Returns `true` on success, `false` on failure.
+	node_set_list_delim :: proc(node: ^Node, delim_type: Delim_Type) -> (success: b32) ---
+
+	// Returns starting number of `node`, if it is an ordered list, otherwise 0.
+	node_get_list_start :: proc(node: ^Node) -> (start: c.int) ---
+
+	// Sets starting number of `node`, if it is an ordered list.
+	// Returns `true` on success, `false` on failure.
+	node_set_list_start :: proc(node: ^Node, start: c.int) -> (success: b32) ---
+
+	// Returns `true` if `node` is a tight list, `false` otherwise.
+	node_get_list_tight :: proc(node: ^Node) -> (tight: b32) ---
+
+	// Sets the "tightness" of a list. Returns `true` on success, `false` on failure.
+	node_set_list_tight :: proc(node: ^Node, tight: b32) -> (success: b32) ---
+
+	// Returns the info string from a fenced code block.
+	get_fence_info :: proc(node: ^Node) -> (fence_info: cstring) ---
+
+	// Sets the info string in a fenced code block, returning `true` on success and `false` on failure.
+	node_set_fence_info :: proc(node: ^Node, fence_info: cstring) -> (success: b32) ---
+
+	// 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_url :: proc(node: ^Node) -> (url: cstring) ---
+
+	// Sets the URL of a link or image `node`. Returns `true` on success, `false` on failure.
+	node_set_url :: proc(node: ^Node, url: cstring) -> (success: b32) ---
+
+	// 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_title :: proc(node: ^Node) -> (title: cstring) ---
+
+	// Sets the title of a link or image `node`. Returns `true` on success, `false` on failure.
+	node_set_title :: proc(node: ^Node, title: cstring) -> (success: b32) ---
+
+	// 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_enter :: proc(node: ^Node) -> (on_enter: cstring) ---
+
+	// 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_enter :: proc(node: ^Node, on_enter: cstring) -> (success: b32) ---
+
+	// Returns the line on which `node` begins.
+	node_get_start_line :: proc(node: ^Node) -> (line: c.int) ---
+
+	// Returns the column at which `node` begins.
+	node_get_start_column :: proc(node: ^Node) -> (column: c.int) ---
+
+	// Returns the line on which `node` ends.
+	node_get_end_line :: proc(node: ^Node) -> (line: c.int) ---
+
+	// Returns the column at which `node` ends.
+	node_get_end_column :: proc(node: ^Node) -> (column: c.int) ---
+}
+
+// Tree Manipulation
+@(default_calling_convention="c", link_prefix="cmark_")
+foreign lib {
+	// Unlinks a `node`, removing it from the tree, but not freeing its memory.
+	// (Use `node_free` for that.)
+	node_unlink :: proc(node: ^Node) ---
+
+	// Inserts 'sibling' before `node`.  Returns `true` on success, `false` on failure.
+	node_insert_before :: proc(node: ^Node, sibling: ^Node) -> (success: b32) ---
+
+	// Inserts 'sibling' after `node`. Returns `true` on success, `false` on failure.
+	node_insert_after :: proc(node: ^Node, sibling: ^Node) -> (success: b32) ---
+
+	// Replaces 'oldnode' with 'newnode' and unlinks 'oldnode'
+	// (but does not free its memory).
+	// Returns `true` on success, `false` on failure.
+	node_replace :: proc(old_node: ^Node, new_node: ^Node) -> (success: b32) ---
+
+	// Adds 'child' to the beginning of the children of `node`.
+	// Returns `true` on success, `false` on failure.
+	node_prepend_child :: proc(node: ^Node, child: ^Node) -> (success: b32) ---
+
+	// Adds 'child' to the end of the children of `node`.
+	// Returns `true` on success, `false` on failure.
+	node_append_child :: proc(node: ^Node, child: ^Node) -> (success: b32) ---
+
+	// Consolidates adjacent text nodes.
+	consolidate_text_nodes :: proc(root: ^Node) ---
+}
+
+Parser :: distinct rawptr
+
+@(default_calling_convention="c", link_prefix="cmark_")
+foreign lib {
+	// Creates a new parser object.
+	parser_new :: proc(options: Options) -> (parser: ^Parser) ---
+
+	// Creates a new parser object with the given memory allocator.
+	parser_new_with_mem :: proc(options: Options, mem: ^Allocator) -> (parser: ^Parser) ---
+
+	// Frees memory allocated for a parser object.
+	parser_free :: proc(parser: ^Parser) ---
+
+	// Feeds a string of length 'len' to 'parser'.
+	parser_feed :: proc(parser: ^Parser, buffer: [^]byte, len: c.size_t) ---
+
+	// Finish parsing and return a pointer to a tree of nodes.
+	parser_finish :: proc(parser: ^Parser) -> (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 :: proc(buffer: [^]byte, len: c.size_t, options: Options) -> (root: ^Node) ---
+
+	// 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 'node_free'
+	// when it is no longer needed.
+	//
+	// Called `parse_from_libc_file` so as not to confuse with Odin's file handling.
+
+	@(link_name = "parse_from_file")
+	parse_from_libc_file :: proc(file: ^libc.FILE, options: Options) -> (root: ^Node) ---
+}
+
+parser_feed_from_string :: proc "c" (parser: ^Parser, s: string) {
+	parser_feed(parser, raw_data(s), len(s))
+}
+parse_document_from_string :: proc "c" (s: string, options: Options) -> (root: ^Node) {
+	return parse_document(raw_data(s), len(s), options)
+}
+
+// Rendering
+@(default_calling_convention="c", link_prefix="cmark_")
+foreign lib {
+	// Render a `node` tree as XML.
+	// It is the caller's responsibilityto free the returned buffer.
+	render_xml :: proc(root: ^Node, options: Options) -> (xml: 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_html :: proc(root: ^Node, options: Options) -> (html: 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_man :: proc(root: ^Node, options: Options, width: c.int) -> (groff: cstring) ---
+
+	// Render a `node` tree as a commonmark document.
+	// It is the caller's responsibility to free the returned buffer.
+	render_commonmark :: proc(root: ^Node, options: Options, width: c.int) -> (commonmark: cstring) ---
+
+	// Render a `node` tree as a LaTeX document.
+	// It is the caller's responsibility to free the returned buffer.
+	render_latex :: proc(root: ^Node, options: Options, width: c.int) -> (latex: cstring) ---
+}
+
+// Helpers to free results from `render_*`.
+free_rawptr :: proc "c" (ptr: rawptr) {
+	cmm := get_default_mem_allocator()
+	cmm.free(ptr)
+}
+free_cstring :: proc "c" (str: cstring) {
+	free_rawptr(rawptr(str))
+}
+free_string :: proc "c" (s: string) {
+    free_rawptr(raw_data(s))
+}
+free :: proc{free_rawptr, free_cstring}
+
+// Wrap CMark allocator as Odin allocator
+@(private)
+cmark_allocator_proc :: proc(allocator_data: rawptr, mode: runtime.Allocator_Mode,
+                           size, alignment: int,
+                           old_memory: rawptr, old_size: int, loc := #caller_location) -> (res: []byte, err: runtime.Allocator_Error) {
+
+	cmark_alloc := cast(^Allocator)allocator_data
+	switch mode {
+	case .Alloc:
+		ptr := cmark_alloc.calloc(1, c.size_t(size))
+		res  = transmute([]byte)runtime.Raw_Slice{ptr, size}
+		return res, nil
+
+	case .Free:
+		cmark_alloc.free(old_memory)
+		return nil, nil
+
+	case .Free_All:
+		return nil, .Mode_Not_Implemented
+
+	case .Resize:
+		new_ptr := cmark_alloc.realloc(old_memory, c.size_t(size))
+		res = transmute([]byte)runtime.Raw_Slice{new_ptr, size}
+		if size > old_size {
+			runtime.mem_zero(raw_data(res[old_size:]), size - old_size)
+		}
+		return res, nil
+
+	case .Query_Features:
+		return nil, nil
+
+	case .Query_Info:
+		return nil, .Mode_Not_Implemented
+	}
+	return nil, nil
+}
+
+get_default_mem_allocator_as_odin :: proc() -> runtime.Allocator {
+	return runtime.Allocator{
+		procedure = cmark_allocator_proc,
+		data = rawptr(get_default_mem_allocator()),
+	}
+}
\ No newline at end of file