SYMBOL INDEX (669 symbols across 70 files) FILE: api_test/cplusplus.cpp function test_cplusplus (line 7) | void FILE: api_test/harness.c function test_batch_runner (line 12) | test_batch_runner *test_batch_runner_new() { function test_result (line 16) | static void test_result(test_batch_runner *runner, int cond, const char ... function SKIP (line 30) | void SKIP(test_batch_runner *runner, int num_tests) { function OK (line 35) | void OK(test_batch_runner *runner, int cond, const char *msg, ...) { function INT_EQ (line 42) | void INT_EQ(test_batch_runner *runner, int got, int expected, const char... function STR_EQ (line 72) | void STR_EQ(test_batch_runner *runner, const char *got, const char *expe... function test_ok (line 99) | int test_ok(test_batch_runner *runner) { return runner->num_failed == 0; } function test_print_summary (line 101) | void test_print_summary(test_batch_runner *runner) { FILE: api_test/harness.h type test_batch_runner (line 8) | typedef struct { FILE: api_test/main.c function version (line 39) | static void version(test_batch_runner *runner) { function constructor (line 45) | static void constructor(test_batch_runner *runner) { function accessors (line 78) | static void accessors(test_batch_runner *runner) { function node_check (line 254) | static void node_check(test_batch_runner *runner) { function iterator (line 268) | static void iterator(test_batch_runner *runner) { function iterator_delete (line 287) | static void iterator_delete(test_batch_runner *runner) { function create_tree (line 321) | static void create_tree(test_batch_runner *runner) { function custom_nodes (line 398) | static void custom_nodes(test_batch_runner *runner) { function hierarchy (line 432) | void hierarchy(test_batch_runner *runner) { function test_content (line 479) | static void test_content(test_batch_runner *runner, cmark_node_type type, function parser (line 501) | static void parser(test_batch_runner *runner) { function render_html (line 506) | static void render_html(test_batch_runner *runner) { function render_xml (line 533) | static void render_xml(test_batch_runner *runner) { function render_man (line 577) | static void render_man(test_batch_runner *runner) { function render_latex (line 618) | static void render_latex(test_batch_runner *runner) { function render_commonmark (line 663) | static void render_commonmark(test_batch_runner *runner) { function render_plaintext (line 707) | static void render_plaintext(test_batch_runner *runner) { function utf8 (line 751) | static void utf8(test_batch_runner *runner) { function test_char (line 808) | static void test_char(test_batch_runner *runner, int valid, const char *... function test_incomplete_char (line 822) | static void test_incomplete_char(test_batch_runner *runner, const char *... function test_continuation_byte (line 829) | static void test_continuation_byte(test_batch_runner *runner, function line_endings (line 853) | static void line_endings(test_batch_runner *runner) { function numeric_entities (line 883) | static void numeric_entities(test_batch_runner *runner) { function test_safe (line 915) | static void test_safe(test_batch_runner *runner) { function test_md_to_html (line 930) | static void test_md_to_html(test_batch_runner *runner, const char *markd... function test_feed_across_line_ending (line 938) | static void test_feed_across_line_ending(test_batch_runner *runner) { type timeval (line 951) | struct timeval function test_pathological_regressions (line 969) | static void test_pathological_regressions(test_batch_runner *runner) { function source_pos (line 1004) | static void source_pos(test_batch_runner *runner) { function source_pos_inlines (line 1085) | static void source_pos_inlines(test_batch_runner *runner) { function ref_source_pos (line 1159) | static void ref_source_pos(test_batch_runner *runner) { function inline_only_opt (line 1183) | static void inline_only_opt(test_batch_runner *runner) { function check_markdown_plaintext (line 1203) | static void check_markdown_plaintext(test_batch_runner *runner, const ch... function preserve_whitespace_opt (line 1219) | static void preserve_whitespace_opt(test_batch_runner *runner) { function check_markdown_attributes_node (line 1239) | static void check_markdown_attributes_node(test_batch_runner *runner, co... function verify_custom_attributes_node (line 1258) | static void verify_custom_attributes_node(test_batch_runner *runner) { function cmark_node (line 1270) | static cmark_node* parse_custom_attributues_footnote(test_batch_runner *... function verify_custom_attributes_footnote_basic (line 1278) | static void verify_custom_attributes_footnote_basic(test_batch_runner *r... function verify_custom_attributes_footnote_multiple_footnotes (line 1293) | static void verify_custom_attributes_footnote_multiple_footnotes(test_ba... function verify_custom_attributes_footnote_reuse (line 1311) | static void verify_custom_attributes_footnote_reuse(test_batch_runner *r... function verify_custom_attributes_footnote_mixed_content (line 1334) | static void verify_custom_attributes_footnote_mixed_content(test_batch_r... function verify_custom_attributes_node_with_footnote (line 1360) | static void verify_custom_attributes_node_with_footnote(test_batch_runne... function cmark_node (line 1369) | static cmark_node *reentrant_parse_inline_ext(cmark_syntax_extension *se... function run_inner_parser (line 1382) | static void run_inner_parser() { function parser_interrupt (line 1394) | static void parser_interrupt(test_batch_runner *runner) { function compare_table_spans_html (line 1428) | static void compare_table_spans_html(test_batch_runner *runner, const ch... function table_spans (line 1447) | static void table_spans(test_batch_runner *runner) { function main (line 1582) | int main() { FILE: bench/statistics.py class StatisticsError (line 111) | class StatisticsError(ValueError): function _sum (line 117) | def _sum(data, start=0): function _check_type (line 187) | def _check_type(T, allowed): function _exact_ratio (line 196) | def _exact_ratio(x): function _decimal_to_ratio (line 231) | def _decimal_to_ratio(d): function _counts (line 256) | def _counts(data): function mean (line 272) | def mean(data): function median (line 297) | def median(data): function median_low (line 321) | def median_low(data): function median_high (line 343) | def median_high(data): function median_grouped (line 362) | def median_grouped(data, interval=1): function mode (line 411) | def mode(data): function _ss (line 453) | def _ss(data, c=None): function variance (line 471) | def variance(data, xbar=None): function pvariance (line 518) | def pvariance(data, mu=None): function stdev (line 566) | def stdev(data, xbar=None): function pstdev (line 582) | def pstdev(data, mu=None): FILE: bench/stats.py function pairs (line 6) | def pairs(l, n): FILE: bin/main.c type writer_format (line 38) | typedef enum { function print_usage (line 48) | void print_usage() { function print_document (line 77) | static bool print_document(cmark_node *document, writer_format writer, function print_extensions (line 112) | static void print_extensions(void) { function main (line 128) | int main(int argc, char *argv[]) { FILE: cmake/modules/CheckFileOffsetBits.c function main (line 10) | int main() FILE: extensions/autolink.c function is_valid_hostchar (line 15) | static int is_valid_hostchar(const uint8_t *link, size_t link_len) { function sd_autolink_issafe (line 23) | static int sd_autolink_issafe(const uint8_t *link, size_t link_len) { function autolink_delim (line 40) | static size_t autolink_delim(uint8_t *data, size_t link_end) { function check_domain (line 118) | static size_t check_domain(uint8_t *data, size_t size, int allow_short) { function cmark_node (line 170) | static cmark_node *www_match(cmark_parser *parser, cmark_node *parent, function cmark_node (line 225) | static cmark_node *url_match(cmark_parser *parser, cmark_node *parent, function cmark_node (line 281) | static cmark_node *match(cmark_syntax_extension *ext, cmark_parser *parser, function validate_protocol (line 301) | static bool validate_protocol(const char protocol[], uint8_t *data, size... function postprocess_text (line 323) | static void postprocess_text(cmark_parser *parser, cmark_node *text) { function cmark_node (line 464) | static cmark_node *postprocess(cmark_syntax_extension *ext, cmark_parser... function cmark_syntax_extension (line 497) | cmark_syntax_extension *create_autolink_extension(void) { FILE: extensions/core-extensions.c function core_extensions_registration (line 12) | static int core_extensions_registration(cmark_plugin *plugin) { function register_plugins (line 24) | static void register_plugins(void) { function CMARK_GFM_EXPORT (line 28) | CMARK_GFM_EXPORT FILE: extensions/ext_scanners.c function bufsize_t (line 6) | bufsize_t _ext_scan_at(bufsize_t (*scanner)(const unsigned char *), function bufsize_t (line 23) | bufsize_t _scan_table_start(const unsigned char *p) { function bufsize_t (line 222) | bufsize_t _scan_table_cell(const unsigned char *p) { function bufsize_t (line 466) | bufsize_t _scan_table_cell_end(const unsigned char *p) { function bufsize_t (line 500) | bufsize_t _scan_table_row_end(const unsigned char *p) { function bufsize_t (line 577) | bufsize_t _scan_tasklist(const unsigned char *p) { FILE: extensions/strikethrough.c function cmark_node (line 9) | static cmark_node *match(cmark_syntax_extension *self, cmark_parser *par... function delimiter (line 41) | static delimiter *insert(cmark_syntax_extension *self, cmark_parser *par... function can_contain (line 90) | static int can_contain(cmark_syntax_extension *extension, cmark_node *node, function commonmark_render (line 98) | static void commonmark_render(cmark_syntax_extension *extension, function latex_render (line 104) | static void latex_render(cmark_syntax_extension *extension, function man_render (line 116) | static void man_render(cmark_syntax_extension *extension, function html_render (line 129) | static void html_render(cmark_syntax_extension *extension, function plaintext_render (line 140) | static void plaintext_render(cmark_syntax_extension *extension, function cmark_syntax_extension (line 146) | cmark_syntax_extension *create_strikethrough_extension(void) { FILE: extensions/table.c type node_cell_data (line 25) | typedef struct { type node_cell (line 30) | typedef struct { type table_row (line 36) | typedef struct { type node_table (line 42) | typedef struct { type node_table_row (line 49) | typedef struct { function free_table_cell (line 53) | static void free_table_cell(cmark_mem *mem, node_cell *cell) { function free_row_cells (line 60) | static void free_row_cells(cmark_mem *mem, table_row *row) { function free_table_row (line 68) | static void free_table_row(cmark_mem *mem, table_row *row) { function free_node_table (line 76) | static void free_node_table(cmark_mem *mem, void *ptr) { function free_node_table_row (line 82) | static void free_node_table_row(cmark_mem *mem, void *ptr) { function free_node_table_cell_data (line 86) | static void free_node_table_cell_data(cmark_mem *mem, void *data) { function get_n_table_columns (line 90) | static int get_n_table_columns(cmark_node *node) { function set_n_table_columns (line 97) | static int set_n_table_columns(cmark_node *node, uint16_t n_columns) { function incr_table_row_count (line 112) | static int incr_table_row_count(cmark_node *node, int i) { function get_n_autocompleted_cells (line 123) | static int get_n_autocompleted_cells(cmark_node *node) { function set_table_alignments (line 139) | static int set_table_alignments(cmark_node *node, uint8_t *alignments) { function get_cell_alignment (line 147) | static uint8_t get_cell_alignment(cmark_node *node) { function set_cell_index (line 159) | static int set_cell_index(cmark_node *node, int i) { function get_cell_colspan (line 170) | static unsigned get_cell_colspan(cmark_node *node) { function get_cell_rowspan (line 180) | static unsigned get_cell_rowspan(cmark_node *node) { function set_cell_colspan (line 190) | static int set_cell_colspan(cmark_node *node, unsigned colspan) { function set_cell_rowspan (line 201) | static int set_cell_rowspan(cmark_node *node, unsigned rowspan) { function increment_cell_rowspan (line 212) | static int increment_cell_rowspan(cmark_node *node) { function cmark_strbuf (line 223) | static cmark_strbuf *unescape_pipes(cmark_mem *mem, unsigned char *strin... function node_cell (line 246) | static node_cell* append_row_cell(cmark_mem *mem, table_row *row) { function table_row (line 262) | static table_row *row_from_string(cmark_syntax_extension *self, function try_inserting_table_header_paragraph (line 401) | static void try_inserting_table_header_paragraph(cmark_parser *parser, function cmark_node (line 421) | static cmark_node *try_opening_table_header(cmark_syntax_extension *self, function cmark_node (line 548) | static cmark_node *try_opening_table_row(cmark_syntax_extension *self, function cmark_node (line 642) | static cmark_node *try_opening_table_block(cmark_syntax_extension *self, function matches (line 657) | static int matches(cmark_syntax_extension *self, cmark_parser *parser, function can_contain (line 692) | static int can_contain(cmark_syntax_extension *extension, cmark_node *node, function contains_inlines (line 709) | static int contains_inlines(cmark_syntax_extension *extension, function commonmark_render (line 714) | static void commonmark_render(cmark_syntax_extension *extension, function latex_render (line 769) | static void latex_render(cmark_syntax_extension *extension, function man_render (line 856) | static void man_render(cmark_syntax_extension *extension, function html_table_add_align (line 911) | static void html_table_add_align(cmark_strbuf* html, const char* align, ... function html_table_add_spans (line 923) | static void html_table_add_spans(cmark_strbuf *html, unsigned colspan, u... type html_table_state (line 940) | struct html_table_state { function html_render (line 945) | static void html_render(cmark_syntax_extension *extension, function opaque_alloc (line 1033) | static void opaque_alloc(cmark_syntax_extension *self, cmark_mem *mem, c... function opaque_free (line 1043) | static void opaque_free(cmark_syntax_extension *self, cmark_mem *mem, cm... function escape (line 1053) | static int escape(cmark_syntax_extension *self, cmark_node *node, int c) { function cmark_syntax_extension (line 1061) | cmark_syntax_extension *create_table_extension(void) { function CMARK_GFM_EXPORT (line 1086) | CMARK_GFM_EXPORT function CMARK_GFM_EXPORT (line 1094) | CMARK_GFM_EXPORT function CMARK_GFM_EXPORT (line 1102) | CMARK_GFM_EXPORT function CMARK_GFM_EXPORT (line 1107) | CMARK_GFM_EXPORT function CMARK_GFM_EXPORT (line 1114) | CMARK_GFM_EXPORT function CMARK_GFM_EXPORT (line 1123) | CMARK_GFM_EXPORT function cmark_gfm_extensions_get_table_cell_colspan (line 1133) | CMARK_GFM_EXPORT function cmark_gfm_extensions_get_table_cell_rowspan (line 1139) | CMARK_GFM_EXPORT function CMARK_GFM_EXPORT (line 1145) | CMARK_GFM_EXPORT function CMARK_GFM_EXPORT (line 1151) | CMARK_GFM_EXPORT FILE: extensions/tagfilter.c function is_tag (line 10) | static int is_tag(const unsigned char *tag_data, size_t tag_size, function filter (line 43) | static int filter(cmark_syntax_extension *ext, const unsigned char *tag, function cmark_syntax_extension (line 56) | cmark_syntax_extension *create_tagfilter_extension(void) { FILE: extensions/tasklist.c type cmark_tasklist_type (line 9) | typedef enum { function CMARK_GFM_EXPORT (line 23) | CMARK_GFM_EXPORT function CMARK_GFM_EXPORT (line 33) | CMARK_GFM_EXPORT function parse_node_item_prefix (line 46) | static bool parse_node_item_prefix(cmark_parser *parser, const char *input, function matches (line 67) | static int matches(cmark_syntax_extension *self, cmark_parser *parser, function can_contain (line 73) | static int can_contain(cmark_syntax_extension *extension, cmark_node *node, function cmark_node (line 78) | static cmark_node *open_tasklist_item(cmark_syntax_extension *self, function commonmark_render (line 101) | static void commonmark_render(cmark_syntax_extension *extension, function html_render (line 119) | static void html_render(cmark_syntax_extension *extension, function cmark_syntax_extension (line 147) | cmark_syntax_extension *create_tasklist_extension(void) { FILE: fuzz/fuzz_quadratic.c function LLVMFuzzerInitialize (line 19) | int LLVMFuzzerInitialize(int *argc, char ***argv) { function LLVMFuzzerTestOneInput (line 24) | int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { FILE: fuzz/fuzz_quadratic_brackets.c function LLVMFuzzerInitialize (line 19) | int LLVMFuzzerInitialize(int *argc, char ***argv) { function LLVMFuzzerTestOneInput (line 24) | int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { FILE: man/make_man_page.py function md2man (line 36) | def md2man(text): function handle_quotes (line 57) | def handle_quotes(s): FILE: src/arena.c function arena_chunk (line 8) | CMARK_DEFINE_LOCK(arena) type arena_chunk (line 17) | struct arena_chunk type arena_chunk (line 17) | struct arena_chunk type arena_chunk (line 18) | struct arena_chunk type arena_chunk (line 18) | struct arena_chunk function cmark_arena_push (line 29) | void cmark_arena_push(void) { function cmark_arena_pop (line 38) | int cmark_arena_pop(void) { function init_arena (line 57) | static void init_arena(void) { function cmark_arena_reset (line 63) | void cmark_arena_reset(void) { type arena_chunk (line 87) | struct arena_chunk function arena_free (line 114) | static void arena_free(void *ptr) { function cmark_mem (line 121) | cmark_mem *cmark_get_arena_mem_allocator(void) { FILE: src/blocks.c function S_last_line_blank (line 45) | static bool S_last_line_blank(const cmark_node *node) { function S_last_line_checked (line 49) | static bool S_last_line_checked(const cmark_node *node) { function cmark_node_type (line 53) | static inline cmark_node_type S_type(const cmark_node *node) { function S_set_last_line_blank (line 57) | static void S_set_last_line_blank(cmark_node *node, bool is_blank) { function S_set_last_line_checked (line 64) | static void S_set_last_line_checked(cmark_node *node) { function S_is_line_end_char (line 68) | static inline bool S_is_line_end_char(char c) { function S_is_space_or_tab (line 72) | static inline bool S_is_space_or_tab(char c) { function cmark_node (line 82) | static cmark_node *make_block(cmark_mem *mem, cmark_node_type tag, function cmark_node (line 98) | static cmark_node *make_document(cmark_mem *mem) { function cmark_parser_attach_syntax_extension (line 103) | int cmark_parser_attach_syntax_extension(cmark_parser *parser, function cmark_parser_dispose (line 124) | static void cmark_parser_dispose(cmark_parser *parser) { function cmark_parser_reset (line 132) | static void cmark_parser_reset(cmark_parser *parser) { function cmark_parser (line 162) | cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem) { function cmark_parser (line 172) | cmark_parser *cmark_parser_new(int options) { function cmark_parser_free (line 177) | void cmark_parser_free(cmark_parser *parser) { function is_blank (line 197) | static bool is_blank(cmark_strbuf *s, bufsize_t offset) { function accepts_lines (line 217) | static inline bool accepts_lines(cmark_node_type block_type) { function contains_inlines (line 223) | static inline bool contains_inlines(cmark_node *node) { function add_line (line 232) | static void add_line(cmark_node *node, cmark_chunk *ch, cmark_parser *pa... function remove_trailing_blank_lines (line 248) | static void remove_trailing_blank_lines(cmark_strbuf *ln) { function S_ends_with_blank_line (line 277) | static bool S_ends_with_blank_line(cmark_node *node) { function resolve_reference_link_definitions (line 291) | static bool resolve_reference_link_definitions( function cmark_node (line 309) | static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { function cmark_node (line 421) | static cmark_node *add_child(cmark_parser *parser, cmark_node *parent, function cmark_manage_extensions_special_characters (line 446) | void cmark_manage_extensions_special_characters(cmark_parser *parser, in... function process_inlines (line 464) | static void process_inlines(cmark_parser *parser, function sort_footnote_by_ix (line 486) | static int sort_footnote_by_ix(const void *_a, const void *_b) { function process_footnotes (line 492) | static void process_footnotes(cmark_parser *parser) { function bufsize_t (line 578) | static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input, function lists_match (line 665) | static int lists_match(cmark_list *list_data, cmark_list *item_data) { function cmark_node (line 672) | static cmark_node *finalize_document(cmark_parser *parser) { function cmark_node (line 693) | cmark_node *cmark_parse_file(FILE *f, int options) { function cmark_node (line 712) | cmark_node *cmark_parse_document(const char *buffer, size_t len, int opt... function cmark_parser_feed (line 723) | void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t ... function cmark_parser_feed_reentrant (line 727) | void cmark_parser_feed_reentrant(cmark_parser *parser, const char *buffe... function S_parser_feed (line 740) | static void S_parser_feed(cmark_parser *parser, const unsigned char *buf... function chop_trailing_hashtags (line 812) | static void chop_trailing_hashtags(cmark_chunk *ch) { function S_scan_thematic_break (line 835) | static int S_scan_thematic_break(cmark_parser *parser, cmark_chunk *input, function S_find_first_nonspace (line 866) | static void S_find_first_nonspace(cmark_parser *parser, cmark_chunk *inp... function S_advance_offset (line 904) | static void S_advance_offset(cmark_parser *parser, cmark_chunk *input, function S_last_child_is_open (line 933) | static bool S_last_child_is_open(cmark_node *container) { function parse_block_quote_prefix (line 938) | static bool parse_block_quote_prefix(cmark_parser *parser, cmark_chunk *... function parse_footnote_definition_block_prefix (line 957) | static bool parse_footnote_definition_block_prefix(cmark_parser *parser,... function parse_node_item_prefix (line 969) | static bool parse_node_item_prefix(cmark_parser *parser, cmark_chunk *in... function parse_code_block_prefix (line 990) | static bool parse_code_block_prefix(cmark_parser *parser, cmark_chunk *i... function parse_html_block_prefix (line 1033) | static bool parse_html_block_prefix(cmark_parser *parser, function parse_extension_block (line 1057) | static bool parse_extension_block(cmark_parser *parser, function cmark_node (line 1080) | static cmark_node *check_open_blocks(cmark_parser *parser, cmark_chunk *... function open_new_blocks (line 1148) | static void open_new_blocks(cmark_parser *parser, cmark_node **container, function add_text_to_container (line 1367) | static void add_text_to_container(cmark_parser *parser, cmark_node *cont... function S_process_line (line 1487) | static void S_process_line(cmark_parser *parser, const unsigned char *bu... function cmark_node (line 1558) | cmark_node *cmark_parser_finish(cmark_parser *parser) { function cmark_parser_get_line_number (line 1601) | int cmark_parser_get_line_number(cmark_parser *parser) { function bufsize_t (line 1605) | bufsize_t cmark_parser_get_offset(cmark_parser *parser) { function bufsize_t (line 1609) | bufsize_t cmark_parser_get_column(cmark_parser *parser) { function cmark_parser_get_first_nonspace (line 1613) | int cmark_parser_get_first_nonspace(cmark_parser *parser) { function cmark_parser_get_first_nonspace_column (line 1617) | int cmark_parser_get_first_nonspace_column(cmark_parser *parser) { function cmark_parser_get_indent (line 1621) | int cmark_parser_get_indent(cmark_parser *parser) { function cmark_parser_is_blank (line 1625) | int cmark_parser_is_blank(cmark_parser *parser) { function cmark_parser_has_partially_consumed_tab (line 1629) | int cmark_parser_has_partially_consumed_tab(cmark_parser *parser) { function cmark_parser_get_last_line_length (line 1633) | int cmark_parser_get_last_line_length(cmark_parser *parser) { function cmark_node (line 1637) | cmark_node *cmark_parser_add_child(cmark_parser *parser, function cmark_parser_advance_offset (line 1644) | void cmark_parser_advance_offset(cmark_parser *parser, function cmark_parser_set_backslash_ispunct_func (line 1653) | void cmark_parser_set_backslash_ispunct_func(cmark_parser *parser, function cmark_llist (line 1658) | cmark_llist *cmark_parser_get_syntax_extensions(cmark_parser *parser) { FILE: src/buffer.c function cmark_strbuf_init (line 23) | void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf, function S_strbuf_grow_by (line 34) | static inline void S_strbuf_grow_by(cmark_strbuf *buf, bufsize_t add) { function cmark_strbuf_grow (line 38) | void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) { function bufsize_t (line 62) | bufsize_t cmark_strbuf_len(const cmark_strbuf *buf) { return buf->size; } function cmark_strbuf_free (line 64) | void cmark_strbuf_free(cmark_strbuf *buf) { function cmark_strbuf_clear (line 74) | void cmark_strbuf_clear(cmark_strbuf *buf) { function cmark_strbuf_set (line 81) | void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, function cmark_strbuf_sets (line 96) | void cmark_strbuf_sets(cmark_strbuf *buf, const char *string) { function cmark_strbuf_putc (line 101) | void cmark_strbuf_putc(cmark_strbuf *buf, int c) { function cmark_strbuf_put (line 107) | void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, function cmark_strbuf_puts (line 118) | void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) { function cmark_strbuf_copy_cstr (line 122) | void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, function cmark_strbuf_swap (line 142) | void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) { function cmark_strbuf_cmp (line 160) | int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b) { function bufsize_t (line 166) | bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t ... function bufsize_t (line 180) | bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t... function cmark_strbuf_truncate (line 195) | void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len) { function cmark_strbuf_drop (line 205) | void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n) { function cmark_strbuf_rtrim (line 217) | void cmark_strbuf_rtrim(cmark_strbuf *buf) { function cmark_strbuf_trim (line 231) | void cmark_strbuf_trim(cmark_strbuf *buf) { function cmark_strbuf_normalize_whitespace (line 247) | void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) { function cmark_strbuf_unescape (line 267) | extern void cmark_strbuf_unescape(cmark_strbuf *buf) { FILE: src/cmark.c function cmark_version (line 13) | int cmark_version(void) { return CMARK_GFM_VERSION; } function xfree (line 35) | static void xfree(void *ptr) { function cmark_mem (line 41) | cmark_mem *cmark_get_default_mem_allocator(void) { FILE: src/cmark_ctype.c function cmark_isspace (line 29) | int cmark_isspace(char c) { return cmark_ctype_class[(uint8_t)c] == 1; } function cmark_ispunct (line 34) | int cmark_ispunct(char c) { return cmark_ctype_class[(uint8_t)c] == 2; } function cmark_isalnum (line 36) | int cmark_isalnum(char c) { function cmark_isdigit (line 42) | int cmark_isdigit(char c) { return cmark_ctype_class[(uint8_t)c] == 3; } function cmark_isalpha (line 44) | int cmark_isalpha(char c) { return cmark_ctype_class[(uint8_t)c] == 4; } FILE: src/commonmark.c function outc (line 26) | static inline void outc(cmark_renderer *renderer, cmark_node *node, function longest_backtick_sequence (line 73) | static int longest_backtick_sequence(const char *code) { function shortest_unused_backtick_sequence (line 92) | static int shortest_unused_backtick_sequence(const char *code) { function is_autolink (line 119) | static bool is_autolink(cmark_node *node) { function S_render_node (line 157) | static int S_render_node(cmark_renderer *renderer, cmark_node *node, FILE: src/footnotes.c function footnote_free (line 7) | static void footnote_free(cmark_map *map, cmark_map_entry *_ref) { function cmark_footnote_create (line 18) | void cmark_footnote_create(cmark_map *map, cmark_node *node) { function cmark_map (line 38) | cmark_map *cmark_footnote_map_new(cmark_mem *mem) { function cmark_unlink_footnotes_map (line 51) | void cmark_unlink_footnotes_map(cmark_map *map) { FILE: src/houdini_href_e.c function houdini_escape_href (line 56) | int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, bufsize_t ... FILE: src/houdini_html_e.c function houdini_escape_html0 (line 45) | int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, bufsize_t... function houdini_escape_html (line 74) | int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t ... FILE: src/houdini_html_u.c function bufsize_t (line 49) | bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, function houdini_unescape_html (line 119) | int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, function houdini_unescape_html_f (line 156) | void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, FILE: src/html.c function escape_html (line 18) | static void escape_html(cmark_strbuf *dest, const unsigned char *source, function filter_html_block (line 23) | static void filter_html_block(cmark_html_renderer *renderer, uint8_t *da... function S_put_footnote_backref (line 64) | static bool S_put_footnote_backref(cmark_html_renderer *renderer, cmark_... function S_render_node (line 106) | static int S_render_node(cmark_html_renderer *renderer, cmark_node *node, FILE: src/include/buffer.h type cmark_strbuf (line 16) | typedef struct { FILE: src/include/chunk.h type cmark_chunk (line 14) | typedef struct cmark_chunk { function cmark_chunk_free (line 20) | static inline void cmark_chunk_free(cmark_mem *mem, cmark_chunk *c) { function cmark_chunk_ltrim (line 29) | static inline void cmark_chunk_ltrim(cmark_chunk *c) { function cmark_chunk_rtrim (line 38) | static inline void cmark_chunk_rtrim(cmark_chunk *c) { function cmark_chunk_trim (line 49) | static inline void cmark_chunk_trim(cmark_chunk *c) { function bufsize_t (line 54) | static inline bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c, function cmark_chunk_set_cstr (line 78) | static inline void cmark_chunk_set_cstr(cmark_mem *mem, cmark_chunk *c, function cmark_chunk (line 96) | static inline cmark_chunk cmark_chunk_literal(const char *data) { function cmark_chunk (line 102) | static inline cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, bufsize... function cmark_chunk (line 108) | static inline cmark_chunk cmark_chunk_buf_detach(cmark_strbuf *buf) { function cmark_chunk (line 120) | static inline cmark_chunk cmark_chunk_ltrim_new(cmark_mem *mem, cmark_ch... function cmark_chunk (line 127) | static inline cmark_chunk cmark_chunk_rtrim_new(cmark_mem *mem, cmark_ch... FILE: src/include/cmark-gfm-extension_api.h type cmark_renderer (line 12) | struct cmark_renderer type cmark_html_renderer (line 13) | struct cmark_html_renderer type cmark_chunk (line 14) | struct cmark_chunk type cmark_plugin (line 42) | typedef struct cmark_plugin cmark_plugin; type cmark_inline_parser (line 111) | typedef struct subject cmark_inline_parser; type delimiter (line 115) | typedef struct delimiter { type cmark_node (line 194) | typedef cmark_node * (*cmark_open_block_func) (cmark_syntax_extension *e... type cmark_node (line 201) | typedef cmark_node *(*cmark_match_inline_func)(cmark_syntax_extension *e... type delimiter (line 207) | typedef delimiter *(*cmark_inline_from_delim_func)(cmark_syntax_extensio... type cmark_renderer (line 233) | struct cmark_renderer type cmark_html_renderer (line 246) | struct cmark_html_renderer type cmark_node (line 255) | typedef cmark_node *(*cmark_postprocess_func) (cmark_syntax_extension *e... FILE: src/include/cmark-gfm.h type cmark_node_type (line 40) | typedef enum { type cmark_list_type (line 81) | typedef enum { type cmark_delim_type (line 87) | typedef enum { type cmark_list_marker_type (line 93) | typedef enum { type cmark_node (line 100) | typedef struct cmark_node cmark_node; type cmark_parser (line 101) | typedef struct cmark_parser cmark_parser; type cmark_iter (line 102) | typedef struct cmark_iter cmark_iter; type cmark_syntax_extension (line 103) | typedef struct cmark_syntax_extension cmark_syntax_extension; type cmark_mem (line 112) | typedef struct cmark_mem { type cmark_llist (line 154) | typedef struct _cmark_llist type cmark_event_type (line 290) | typedef enum { type bufsize_t (line 890) | typedef int32_t bufsize_t; FILE: src/include/footnotes.h type cmark_footnote (line 10) | struct cmark_footnote { type cmark_footnote (line 16) | typedef struct cmark_footnote cmark_footnote; FILE: src/include/html.h function cmark_html_render_cr (line 7) | inline function cmark_html_render_sourcepos (line 15) | inline FILE: src/include/iterator.h type cmark_iter_state (line 10) | typedef struct { type cmark_iter (line 15) | struct cmark_iter { FILE: src/include/map.h type cmark_map_entry (line 10) | struct cmark_map_entry { type cmark_map_entry (line 17) | typedef struct cmark_map_entry cmark_map_entry; type cmark_map (line 19) | struct cmark_map type cmark_map (line 21) | struct cmark_map type cmark_map (line 23) | struct cmark_map { type cmark_map (line 33) | typedef struct cmark_map cmark_map; FILE: src/include/mutex.h function check_latch (line 59) | static inline bool check_latch(int *latch) { FILE: src/include/node.h type cmark_list (line 17) | typedef struct { type cmark_code (line 28) | typedef struct { type cmark_heading (line 37) | typedef struct { type cmark_link (line 42) | typedef struct { type cmark_attribute (line 47) | typedef struct { type cmark_custom (line 51) | typedef struct { type cmark_node__internal_flags (line 56) | enum cmark_node__internal_flags { type cmark_node_internal_flags (line 66) | typedef uint16_t cmark_node_internal_flags; type cmark_node (line 68) | struct cmark_node { function cmark_mem (line 139) | static inline cmark_mem *cmark_node_mem(cmark_node *node) { function CMARK_NODE_TYPE_BLOCK_P (line 144) | static inline bool CMARK_NODE_TYPE_BLOCK_P(cmark_node_type node_type) { function CMARK_NODE_BLOCK_P (line 148) | static inline bool CMARK_NODE_BLOCK_P(cmark_node *node) { function CMARK_NODE_TYPE_INLINE_P (line 152) | static inline bool CMARK_NODE_TYPE_INLINE_P(cmark_node_type node_type) { function CMARK_NODE_INLINE_P (line 156) | static inline bool CMARK_NODE_INLINE_P(cmark_node *node) { FILE: src/include/parser.h type cmark_parser (line 18) | struct cmark_parser { FILE: src/include/plugin.h type cmark_plugin (line 17) | struct cmark_plugin { FILE: src/include/references.h type cmark_reference (line 12) | struct cmark_reference { type cmark_reference (line 20) | typedef struct cmark_reference cmark_reference; FILE: src/include/render.h type cmark_escaping (line 14) | typedef enum { LITERAL, NORMAL, TITLE, URL } cmark_escaping; type cmark_renderer (line 16) | struct cmark_renderer { type cmark_renderer (line 35) | typedef struct cmark_renderer cmark_renderer; type cmark_html_renderer (line 37) | struct cmark_html_renderer { type cmark_html_renderer (line 46) | typedef struct cmark_html_renderer cmark_html_renderer; FILE: src/include/syntax_extension.h type cmark_syntax_extension (line 10) | struct cmark_syntax_extension { FILE: src/inlines.c type bracket_type (line 37) | typedef enum { type bracket (line 43) | typedef struct bracket { type subject (line 58) | typedef struct subject{ function cmark_set_default_skip_chars (line 74) | void cmark_set_default_skip_chars(int8_t **skip_chars, bool use_memcpy) { function S_is_line_end_char (line 83) | static inline bool S_is_line_end_char(char c) { function cmark_node (line 97) | static inline cmark_node *make_literal(subject *subj, cmark_node_type t, function cmark_node (line 112) | static inline cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) { function cmark_node (line 120) | static cmark_node *make_str_with_entities(subject *subj, function append_child (line 134) | static void append_child(cmark_node *node, cmark_node *child) { function cmark_chunk (line 152) | static cmark_chunk chunk_clone(cmark_mem *mem, cmark_chunk *src) { function cmark_chunk (line 166) | static cmark_chunk cmark_clean_autolink(cmark_mem *mem, cmark_chunk *url, function cmark_node (line 184) | static inline cmark_node *make_autolink(subject *subj, int start_column, function subject_from_buf (line 197) | static void subject_from_buf(cmark_mem *mem, int line_number, int block_... function isbacktick (line 217) | static inline int isbacktick(int c) { return (c == '`'); } function peek_char_n (line 219) | static inline unsigned char peek_char_n(subject *subj, bufsize_t n) { function peek_char (line 226) | static inline unsigned char peek_char(subject *subj) { function peek_at (line 230) | static inline unsigned char peek_at(subject *subj, bufsize_t pos) { function is_eof (line 235) | static inline int is_eof(subject *subj) { function skip_spaces (line 242) | static inline bool skip_spaces(subject *subj) { function skip_line_end (line 251) | static inline bool skip_line_end(subject *subj) { function cmark_chunk (line 265) | static inline cmark_chunk take_while(subject *subj, int (*f)(int)) { function count_newlines (line 281) | static int count_newlines(subject *subj, bufsize_t from, bufsize_t len, ... function adjust_subj_node_newlines (line 304) | static void adjust_subj_node_newlines(subject *subj, cmark_node *node, i... function bufsize_t (line 324) | static bufsize_t scan_to_closing_backticks(subject *subj, function S_normalize_code (line 367) | static void S_normalize_code(cmark_strbuf *s) { function cmark_node (line 403) | static cmark_node *handle_backticks(subject *subj, int options) { function scan_delims (line 429) | static int scan_delims(cmark_parser *parser, subject *subj, unsigned cha... function remove_delimiter (line 518) | static void remove_delimiter(subject *subj, delimiter *delim) { function pop_bracket (line 534) | static void pop_bracket(subject *subj) { function push_delimiter (line 543) | static void push_delimiter(subject *subj, unsigned char c, bool can_open, function push_bracket (line 560) | static void push_bracket(subject *subj, bracket_type type, cmark_node *i... function cmark_node (line 580) | static cmark_node *handle_delim(cmark_parser *parser, subject *subj, uns... function cmark_node (line 607) | static cmark_node *handle_hyphen(subject *subj, bool smart) { function cmark_node (line 650) | static cmark_node *handle_period(subject *subj, bool smart) { function cmark_syntax_extension (line 665) | static cmark_syntax_extension *get_extension_for_special_char(cmark_pars... function process_emphasis (line 683) | static void process_emphasis(cmark_parser *parser, subject *subj, bufsiz... function delimiter (line 783) | static delimiter *S_insert_emph(subject *subj, delimiter *opener, function cmark_node (line 848) | static cmark_node *handle_backslash(cmark_parser *parser, subject *subj) { function cmark_node (line 864) | static cmark_node *handle_entity(subject *subj) { function cmark_chunk (line 882) | cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url) { function cmark_chunk (line 898) | cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title) { function cmark_chunk (line 924) | cmark_chunk cmark_clean_attributes(cmark_mem *mem, cmark_chunk *attribut... function cmark_node (line 930) | static cmark_node *handle_pointy_brace(subject *subj, int options) { function link_label (line 1039) | static int link_label(subject *subj, cmark_chunk *raw_label, bool parse_... function bufsize_t (line 1091) | static bufsize_t manual_scan_link_url_2(cmark_chunk *input, bufsize_t of... function bufsize_t (line 1131) | static bufsize_t manual_scan_link_url(cmark_chunk *input, bufsize_t offset, function bufsize_t (line 1162) | static bufsize_t manual_scan_attribute_attributes(cmark_chunk *input, bu... function cmark_node (line 1197) | static cmark_node *handle_close_bracket_attribute(cmark_parser *parser, ... function cmark_node (line 1273) | static cmark_node *handle_close_bracket(cmark_parser *parser, subject *s... function cmark_node (line 1498) | static cmark_node *handle_newline(subject *subj) { function cmark_set_default_special_chars (line 1520) | void cmark_set_default_special_chars(int8_t **special_chars, bool use_me... function bufsize_t (line 1555) | static bufsize_t subject_find_special_char(cmark_parser *parser, subject... function cmark_inlines_add_special_character (line 1569) | void cmark_inlines_add_special_character(cmark_parser *parser, unsigned ... function cmark_inlines_remove_special_character (line 1575) | void cmark_inlines_remove_special_character(cmark_parser *parser, unsign... function cmark_node (line 1581) | static cmark_node *try_extensions(cmark_parser *parser, function parse_inline (line 1601) | static int parse_inline(cmark_parser *parser, subject *subj, cmark_node ... function cmark_parse_inlines (line 1706) | void cmark_parse_inlines(cmark_parser *parser, function spnl (line 1730) | static void spnl(subject *subj) { function bufsize_t (line 1741) | bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input, function bufsize_t (line 1803) | bufsize_t cmark_parse_reference_attributes_inline(cmark_mem *mem, cmark_... function cmark_inline_parser_peek_char (line 1853) | unsigned char cmark_inline_parser_peek_char(cmark_inline_parser *parser) { function cmark_inline_parser_peek_at (line 1857) | unsigned char cmark_inline_parser_peek_at(cmark_inline_parser *parser, b... function cmark_inline_parser_is_eof (line 1861) | int cmark_inline_parser_is_eof(cmark_inline_parser *parser) { function cmark_inline_parser_push_delimiter (line 1895) | void cmark_inline_parser_push_delimiter(cmark_inline_parser *parser, function cmark_inline_parser_remove_delimiter (line 1903) | void cmark_inline_parser_remove_delimiter(cmark_inline_parser *parser, d... function cmark_inline_parser_scan_delimiters (line 1907) | int cmark_inline_parser_scan_delimiters(cmark_inline_parser *parser, function cmark_inline_parser_advance_offset (line 1960) | void cmark_inline_parser_advance_offset(cmark_inline_parser *parser) { function cmark_inline_parser_get_offset (line 1964) | int cmark_inline_parser_get_offset(cmark_inline_parser *parser) { function cmark_inline_parser_set_offset (line 1968) | void cmark_inline_parser_set_offset(cmark_inline_parser *parser, int off... function cmark_inline_parser_get_column (line 1972) | int cmark_inline_parser_get_column(cmark_inline_parser *parser) { function cmark_chunk (line 1976) | cmark_chunk *cmark_inline_parser_get_chunk(cmark_inline_parser *parser) { function cmark_inline_parser_in_bracket (line 1980) | int cmark_inline_parser_in_bracket(cmark_inline_parser *parser, int type) { function cmark_node_unput (line 1997) | void cmark_node_unput(cmark_node *node, int n) { function delimiter (line 2011) | delimiter *cmark_inline_parser_get_last_delimiter(cmark_inline_parser *p... function cmark_inline_parser_get_line (line 2015) | int cmark_inline_parser_get_line(cmark_inline_parser *parser) { FILE: src/iterator.c function cmark_iter (line 10) | cmark_iter *cmark_iter_new(cmark_node *root) { function cmark_iter_free (line 25) | void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter); } function S_is_leaf (line 27) | static bool S_is_leaf(cmark_node *node) { function cmark_event_type (line 42) | cmark_event_type cmark_iter_next(cmark_iter *iter) { function cmark_iter_reset (line 81) | void cmark_iter_reset(cmark_iter *iter, cmark_node *current, function cmark_node (line 88) | cmark_node *cmark_iter_get_node(cmark_iter *iter) { return iter->cur.nod... function cmark_event_type (line 90) | cmark_event_type cmark_iter_get_event_type(cmark_iter *iter) { function cmark_node (line 94) | cmark_node *cmark_iter_get_root(cmark_iter *iter) { return iter->root; } function cmark_consolidate_text_nodes (line 96) | void cmark_consolidate_text_nodes(cmark_node *root) { function cmark_node_own (line 129) | void cmark_node_own(cmark_node *root) { FILE: src/latex.c function outc (line 22) | static inline void outc(cmark_renderer *renderer, cmark_node *node, type link_type (line 146) | typedef enum { function link_type (line 154) | static link_type get_link_type(cmark_node *node) { function S_get_enumlevel (line 209) | static int S_get_enumlevel(cmark_node *node) { function S_render_node (line 222) | static int S_render_node(cmark_renderer *renderer, cmark_node *node, FILE: src/linked_list.c function cmark_llist (line 5) | cmark_llist *cmark_llist_append(cmark_mem *mem, cmark_llist *head, void ... function cmark_llist_free_full (line 22) | void cmark_llist_free_full(cmark_mem *mem, cmark_llist *head, cmark_free... function cmark_llist_free (line 35) | void cmark_llist_free(cmark_mem *mem, cmark_llist *head) { FILE: src/man.c function S_outc (line 22) | static void S_outc(cmark_renderer *renderer, cmark_node *node, function S_render_node (line 76) | static int S_render_node(cmark_renderer *renderer, cmark_node *node, FILE: src/map.c function labelcmp (line 34) | static int function refcmp (line 39) | static int function refsearch (line 47) | static int function sort_map (line 53) | static void sort_map(cmark_map *map) { function cmark_map_entry (line 74) | cmark_map_entry *cmark_map_lookup(cmark_map *map, cmark_chunk *label) { function cmark_map_free (line 106) | void cmark_map_free(cmark_map *map) { function cmark_map (line 123) | cmark_map *cmark_map_new(cmark_mem *mem, cmark_map_free_f free) { FILE: src/node.c function cmark_enable_safety_checks (line 19) | void cmark_enable_safety_checks(bool enable) { function S_safety_checks_enabled (line 29) | static bool S_safety_checks_enabled() { function cmark_register_node_flag (line 40) | void cmark_register_node_flag(cmark_node_internal_flags *flags) { function cmark_init_standard_node_flags (line 64) | void cmark_init_standard_node_flags(void) {} function cmark_node_can_contain_type (line 66) | bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child... function S_can_contain (line 105) | static bool S_can_contain(cmark_node *node, cmark_node *child) { function cmark_node (line 127) | cmark_node *cmark_node_new_with_mem_and_ext(cmark_node_type type, cmark_... function cmark_node (line 157) | cmark_node *cmark_node_new_with_ext(cmark_node_type type, cmark_syntax_e... function cmark_node (line 162) | cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) function cmark_node (line 167) | cmark_node *cmark_node_new(cmark_node_type type) { function free_node_as (line 171) | static void free_node_as(cmark_node *node) { function S_free_nodes (line 204) | static void S_free_nodes(cmark_node *e) { function cmark_node_free (line 228) | void cmark_node_free(cmark_node *node) { function cmark_node_type (line 234) | cmark_node_type cmark_node_get_type(cmark_node *node) { function cmark_node_set_type (line 242) | int cmark_node_set_type(cmark_node * node, cmark_node_type type) { function cmark_node (line 324) | cmark_node *cmark_node_next(cmark_node *node) { function cmark_node (line 332) | cmark_node *cmark_node_previous(cmark_node *node) { function cmark_node (line 340) | cmark_node *cmark_node_parent(cmark_node *node) { function cmark_node (line 348) | cmark_node *cmark_node_first_child(cmark_node *node) { function cmark_node (line 356) | cmark_node *cmark_node_last_child(cmark_node *node) { function cmark_node (line 364) | cmark_node *cmark_node_nth_child(cmark_node *node, int n) { function cmark_node (line 377) | cmark_node *cmark_node_parent_footnote_def(cmark_node *node) { function cmark_node_set_user_data (line 393) | int cmark_node_set_user_data(cmark_node *node, void *user_data) { function cmark_node_set_user_data_free_func (line 401) | int cmark_node_set_user_data_free_func(cmark_node *node, function cmark_node_get_backtick_count (line 434) | int cmark_node_get_backtick_count(cmark_node *node) { function cmark_node_set_literal (line 438) | int cmark_node_set_literal(cmark_node *node, const char *content) { function cmark_node_set_string_content (line 467) | int cmark_node_set_string_content(cmark_node *node, const char *content) { function cmark_node_get_heading_level (line 472) | int cmark_node_get_heading_level(cmark_node *node) { function cmark_node_set_heading_level (line 488) | int cmark_node_set_heading_level(cmark_node *node, int level) { function cmark_list_type (line 505) | cmark_list_type cmark_node_get_list_type(cmark_node *node) { function cmark_node_set_list_type (line 517) | int cmark_node_set_list_type(cmark_node *node, cmark_list_type type) { function cmark_list_marker_type (line 534) | cmark_list_marker_type cmark_node_get_list_marker(cmark_node *node) { function cmark_node_set_list_marker (line 547) | int cmark_node_set_list_marker(cmark_node *node, cmark_list_marker_type ... function cmark_delim_type (line 571) | cmark_delim_type cmark_node_get_list_delim(cmark_node *node) { function cmark_node_set_list_delim (line 583) | int cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim) { function cmark_node_get_list_start (line 600) | int cmark_node_get_list_start(cmark_node *node) { function cmark_node_set_list_start (line 612) | int cmark_node_set_list_start(cmark_node *node, int start) { function cmark_node_get_list_tight (line 625) | int cmark_node_get_list_tight(cmark_node *node) { function cmark_node_set_list_tight (line 637) | int cmark_node_set_list_tight(cmark_node *node, int tight) { function cmark_node_get_item_index (line 650) | int cmark_node_get_item_index(cmark_node *node) { function cmark_node_set_item_index (line 662) | int cmark_node_set_item_index(cmark_node *node, int idx) { function cmark_node_set_fence_info (line 687) | int cmark_node_set_fence_info(cmark_node *node, const char *info) { function cmark_node_get_fenced (line 700) | int cmark_node_get_fenced(cmark_node *node, int *length, int *offset, ch... function cmark_node_set_fenced (line 715) | int cmark_node_set_fenced(cmark_node * node, int fenced, function cmark_node_set_url (line 748) | int cmark_node_set_url(cmark_node *node, const char *url) { function cmark_node_set_title (line 781) | int cmark_node_set_title(cmark_node *node, const char *title) { function cmark_node_set_attributes (line 813) | int cmark_node_set_attributes(cmark_node *node, const char *attributes) { function cmark_node_set_on_enter (line 845) | int cmark_node_set_on_enter(cmark_node *node, const char *on_enter) { function cmark_node_set_on_exit (line 878) | int cmark_node_set_on_exit(cmark_node *node, const char *on_exit) { function cmark_syntax_extension (line 895) | cmark_syntax_extension *cmark_node_get_syntax_extension(cmark_node *node) { function cmark_node_set_syntax_extension (line 903) | int cmark_node_set_syntax_extension(cmark_node *node, cmark_syntax_exten... function cmark_node_get_start_line (line 912) | int cmark_node_get_start_line(cmark_node *node) { function cmark_node_get_start_column (line 919) | int cmark_node_get_start_column(cmark_node *node) { function cmark_node_get_end_line (line 926) | int cmark_node_get_end_line(cmark_node *node) { function cmark_node_get_end_column (line 933) | int cmark_node_get_end_column(cmark_node *node) { function S_node_unlink (line 941) | static void S_node_unlink(cmark_node *node) { function cmark_node_unlink (line 965) | void cmark_node_unlink(cmark_node *node) { function cmark_node_insert_before (line 973) | int cmark_node_insert_before(cmark_node *node, cmark_node *sibling) { function cmark_node_insert_after (line 1006) | int cmark_node_insert_after(cmark_node *node, cmark_node *sibling) { function cmark_node_replace (line 1039) | int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode) { function cmark_node_prepend_child (line 1047) | int cmark_node_prepend_child(cmark_node *node, cmark_node *child) { function cmark_node_append_child (line 1071) | int cmark_node_append_child(cmark_node *node, cmark_node *child) { function S_print_error (line 1095) | static void S_print_error(FILE *out, cmark_node *node, const char *elem) { function cmark_node_check (line 1104) | int cmark_node_check(cmark_node *node, FILE *out) { FILE: src/plaintext.c function outc (line 15) | static inline void outc(cmark_renderer *renderer, cmark_node *node, function S_render_node (line 20) | static int S_render_node(cmark_renderer *renderer, cmark_node *node, FILE: src/plugin.c function cmark_plugin_register_syntax_extension (line 7) | int cmark_plugin_register_syntax_extension(cmark_plugin * plugin, function cmark_plugin (line 13) | cmark_plugin * function cmark_plugin_free (line 22) | void function cmark_llist (line 30) | cmark_llist * FILE: src/references.c function reference_free (line 9) | static void reference_free(cmark_map *map, cmark_map_entry *_ref) { function cmark_reference_create (line 21) | void cmark_reference_create(cmark_map *map, cmark_chunk *label, function cmark_reference_create_attributes (line 46) | void cmark_reference_create_attributes(cmark_map *map, cmark_chunk *label, function cmark_map (line 70) | cmark_map *cmark_reference_map_new(cmark_mem *mem) { FILE: src/registry.c function cmark_register_plugin (line 18) | void cmark_register_plugin(cmark_plugin_init_func reg_fn) { function cmark_release_plugins (line 41) | void cmark_release_plugins(void) { function cmark_llist (line 55) | cmark_llist *cmark_list_syntax_extensions(cmark_mem *mem) { function cmark_syntax_extension (line 69) | cmark_syntax_extension *cmark_find_syntax_extension(const char *name) { FILE: src/render.c function S_cr (line 12) | static inline void S_cr(cmark_renderer *renderer) { function S_blankline (line 18) | static inline void S_blankline(cmark_renderer *renderer) { function S_out (line 24) | static void S_out(cmark_renderer *renderer, cmark_node *node, function cmark_render_ascii (line 149) | void cmark_render_ascii(cmark_renderer *renderer, const char *s) { function cmark_render_code_point (line 155) | void cmark_render_code_point(cmark_renderer *renderer, uint32_t c) { FILE: src/scanners.c function bufsize_t (line 6) | bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_ch... function bufsize_t (line 25) | bufsize_t _scan_scheme(const unsigned char *p) { function bufsize_t (line 749) | bufsize_t _scan_autolink_uri(const unsigned char *p) { function bufsize_t (line 1582) | bufsize_t _scan_autolink_email(const unsigned char *p) { function bufsize_t (line 4851) | bufsize_t _scan_html_tag(const unsigned char *p) { function bufsize_t (line 5416) | bufsize_t _scan_liberal_html_tag(const unsigned char *p) { function bufsize_t (line 5673) | bufsize_t _scan_html_comment(const unsigned char *p) { function bufsize_t (line 5864) | bufsize_t _scan_html_pi(const unsigned char *p) { function bufsize_t (line 6126) | bufsize_t _scan_html_declaration(const unsigned char *p) { function bufsize_t (line 6274) | bufsize_t _scan_html_cdata(const unsigned char *p) { function bufsize_t (line 6501) | bufsize_t _scan_html_block_start(const unsigned char *p) { function bufsize_t (line 8266) | bufsize_t _scan_html_block_start_7(const unsigned char *p) { function bufsize_t (line 8850) | bufsize_t _scan_html_block_end_1(const unsigned char *p) { function bufsize_t (line 10047) | bufsize_t _scan_html_block_end_2(const unsigned char *p) { function bufsize_t (line 10399) | bufsize_t _scan_html_block_end_3(const unsigned char *p) { function bufsize_t (line 10717) | bufsize_t _scan_html_block_end_4(const unsigned char *p) { function bufsize_t (line 10982) | bufsize_t _scan_html_block_end_5(const unsigned char *p) { function bufsize_t (line 11336) | bufsize_t _scan_link_title(const unsigned char *p) { function bufsize_t (line 11900) | bufsize_t _scan_spacechars(const unsigned char *p) { function bufsize_t (line 11936) | bufsize_t _scan_atx_heading_start(const unsigned char *p) { function bufsize_t (line 12072) | bufsize_t _scan_setext_heading_line(const unsigned char *p) { function bufsize_t (line 12214) | bufsize_t _scan_open_code_fence(const unsigned char *p) { function bufsize_t (line 12562) | bufsize_t _scan_close_code_fence(const unsigned char *p) { function bufsize_t (line 12709) | bufsize_t _scan_entity(const unsigned char *p) { function bufsize_t (line 13608) | bufsize_t _scan_dangerous_url(const unsigned char *p) { function bufsize_t (line 13922) | bufsize_t _scan_footnote_definition(const unsigned char *p) { FILE: src/syntax_extension.c function cmark_syntax_extension_free (line 13) | void cmark_syntax_extension_free(cmark_mem *mem, cmark_syntax_extension ... function cmark_syntax_extension (line 23) | cmark_syntax_extension *cmark_syntax_extension_new(const char *name) { function cmark_node_type (line 35) | cmark_node_type cmark_syntax_extension_add_node(int is_inline) { function cmark_syntax_extension_set_emphasis (line 46) | void cmark_syntax_extension_set_emphasis(cmark_syntax_extension *extension, function cmark_syntax_extension_set_open_block_func (line 51) | void cmark_syntax_extension_set_open_block_func(cmark_syntax_extension *... function cmark_syntax_extension_set_match_block_func (line 56) | void cmark_syntax_extension_set_match_block_func(cmark_syntax_extension ... function cmark_syntax_extension_set_match_inline_func (line 61) | void cmark_syntax_extension_set_match_inline_func(cmark_syntax_extension... function cmark_syntax_extension_set_inline_from_delim_func (line 66) | void cmark_syntax_extension_set_inline_from_delim_func(cmark_syntax_exte... function cmark_syntax_extension_set_special_inline_chars (line 71) | void cmark_syntax_extension_set_special_inline_chars(cmark_syntax_extens... function cmark_syntax_extension_set_get_type_string_func (line 76) | void cmark_syntax_extension_set_get_type_string_func(cmark_syntax_extens... function cmark_syntax_extension_set_can_contain_func (line 81) | void cmark_syntax_extension_set_can_contain_func(cmark_syntax_extension ... function cmark_syntax_extension_set_contains_inlines_func (line 86) | void cmark_syntax_extension_set_contains_inlines_func(cmark_syntax_exten... function cmark_syntax_extension_set_commonmark_render_func (line 91) | void cmark_syntax_extension_set_commonmark_render_func(cmark_syntax_exte... function cmark_syntax_extension_set_plaintext_render_func (line 96) | void cmark_syntax_extension_set_plaintext_render_func(cmark_syntax_exten... function cmark_syntax_extension_set_latex_render_func (line 101) | void cmark_syntax_extension_set_latex_render_func(cmark_syntax_extension... function cmark_syntax_extension_set_xml_attr_func (line 106) | void cmark_syntax_extension_set_xml_attr_func(cmark_syntax_extension *ex... function cmark_syntax_extension_set_man_render_func (line 111) | void cmark_syntax_extension_set_man_render_func(cmark_syntax_extension *... function cmark_syntax_extension_set_html_render_func (line 116) | void cmark_syntax_extension_set_html_render_func(cmark_syntax_extension ... function cmark_syntax_extension_set_html_filter_func (line 121) | void cmark_syntax_extension_set_html_filter_func(cmark_syntax_extension ... function cmark_syntax_extension_set_postprocess_func (line 126) | void cmark_syntax_extension_set_postprocess_func(cmark_syntax_extension ... function cmark_syntax_extension_set_private (line 131) | void cmark_syntax_extension_set_private(cmark_syntax_extension *extension, function cmark_syntax_extension_set_opaque_alloc_func (line 142) | void cmark_syntax_extension_set_opaque_alloc_func(cmark_syntax_extension... function cmark_syntax_extension_set_opaque_free_func (line 147) | void cmark_syntax_extension_set_opaque_free_func(cmark_syntax_extension ... function cmark_syntax_extension_set_commonmark_escape_func (line 152) | void cmark_syntax_extension_set_commonmark_escape_func(cmark_syntax_exte... FILE: src/utf8.c function encode_unknown (line 21) | static void encode_unknown(cmark_strbuf *buf) { function utf8proc_charlen (line 26) | static int utf8proc_charlen(const uint8_t *str, bufsize_t str_len) { function utf8proc_valid (line 49) | static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) { function cmark_utf8proc_check (line 110) | void cmark_utf8proc_check(cmark_strbuf *ob, const uint8_t *line, function cmark_utf8proc_iterate (line 150) | int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, function cmark_utf8proc_encode_char (line 189) | void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) { function cmark_utf8proc_case_fold (line 227) | void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, function cmark_utf8proc_is_space (line 249) | int cmark_utf8proc_is_space(int32_t uc) { function cmark_utf8proc_is_punctuation (line 256) | int cmark_utf8proc_is_punctuation(int32_t uc) { FILE: src/xml.c function escape_xml (line 19) | static void escape_xml(cmark_strbuf *dest, const unsigned char *source, type render_state (line 24) | struct render_state { function indent (line 29) | static inline void indent(struct render_state *state) { function S_render_node (line 36) | static int S_render_node(cmark_node *node, cmark_event_type ev_type, type render_state (line 171) | struct render_state FILE: test/cmark-fuzz.c function LLVMFuzzerInitialize (line 15) | int LLVMFuzzerInitialize(int *argc, char ***argv) { function LLVMFuzzerTestOneInput (line 20) | int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { FILE: test/cmark.py function pipe_through_prog (line 9) | def pipe_through_prog(prog, text): function parse (line 14) | def parse(lib, extlib, text, extensions): function to_html (line 50) | def to_html(lib, extlib, text, extensions): function to_commonmark (line 64) | def to_commonmark(lib, extlib, text, extensions): class CMark (line 73) | class CMark: method __init__ (line 74) | def __init__(self, prog=None, library_dir=None, extensions=None): FILE: test/entity_tests.py function get_entities (line 12) | def get_entities(): FILE: test/normalize.py class HTMLParseError (line 11) | class HTMLParseError(Exception): class MyHTMLParser (line 22) | class MyHTMLParser(HTMLParser): method __init__ (line 23) | def __init__(self): method handle_data (line 30) | def handle_data(self, data): method handle_endtag (line 44) | def handle_endtag(self, tag): method handle_starttag (line 52) | def handle_starttag(self, tag, attrs): method handle_startendtag (line 73) | def handle_startendtag(self, tag, attrs): method handle_comment (line 78) | def handle_comment(self, data): method handle_decl (line 81) | def handle_decl(self, data): method unknown_decl (line 84) | def unknown_decl(self, data): method handle_pi (line 87) | def handle_pi(self,data): method handle_entityref (line 90) | def handle_entityref(self, name): method handle_charref (line 97) | def handle_charref(self, name): method output_char (line 108) | def output_char(self, c, fallback): method is_block_tag (line 122) | def is_block_tag(self,tag): function normalize_html (line 131) | def normalize_html(html): FILE: test/pathological_tests.py function hash_collisions (line 12) | def hash_collisions(): function run_test (line 114) | def run_test(inp, regex): FILE: test/roundtrip_tests.py function converter (line 28) | def converter(md, exts): FILE: test/spec_tests.py function out (line 37) | def out(str): function print_test_header (line 40) | def print_test_header(headertext, example_number, start_line, end_line): function do_test (line 43) | def do_test(converter, test, normalize, result_counts): function get_tests (line 82) | def get_tests(specfile): FILE: wrappers/wrapper.py function md2html (line 27) | def md2html(text): FILE: wrappers/wrapper.rb type CMark (line 4) | module CMark function markdown_to_html (line 10) | def markdown_to_html(s) FILE: wrappers/wrapper_ext.py function md2html (line 85) | def md2html(text):