commonmarker 0.10.0 → 0.11.0

data/ext/commonmarker/cmark/extensions/table.h

@@ -0,0 +1,8 @@
+#ifndef TABLE_H
+#define TABLE_H
+
+#include "core-extensions.h"
+
+cmark_syntax_extension *create_table_extension(void);
+
+#endif

data/ext/commonmarker/cmark/extensions/whitelist.c

@@ -0,0 +1,59 @@
+#include "whitelist.h"
+#include <parser.h>
+
+static const char *whitelist[] = {
+  "template", "h1", "h2", "h3", "h4", "h5", "h6", "h7", "h8", "br", "b", "i",
+  "strong", "em", "a", "pre", "code", "img", "tt", "div", "ins", "del", "sup",
+  "sub", "p", "ol", "ul", "table", "thead", "tbody", "tfoot", "blockquote",
+  "dl", "dt", "dd", "kbd", "q", "samp", "var", "hr", "ruby", "rt", "rp", "li",
+  "tr", "td", "th", "s", "strike", "summary", "details",
+  NULL,
+};
+
+static int is_tag(const unsigned char *tag_data, size_t tag_size, const char *tagname)
+{
+  size_t i;
+
+  if (tag_size < 3 || tag_data[0] != '<')
+    return 0;
+
+  i = 1;
+
+  if (tag_data[i] == '/') {
+    i++;
+  }
+
+  for (; i < tag_size; ++i, ++tagname) {
+    if (*tagname == 0)
+      break;
+
+    if (tag_data[i] != *tagname)
+      return 0;
+  }
+
+  if (i == tag_size)
+    return 0;
+
+  if (cmark_isspace(tag_data[i]) || tag_data[i] == '>')
+    return 1;
+
+  return 0;
+}
+
+static int filter(cmark_syntax_extension *ext, const unsigned char *tag, size_t tag_len) {
+  const char **it;
+
+  for (it = whitelist; *it; ++it) {
+    if (is_tag(tag, tag_len, *it)) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+cmark_syntax_extension *create_whitelist_extension(void) {
+  cmark_syntax_extension *ext = cmark_syntax_extension_new("whitelist");
+  cmark_syntax_extension_set_html_filter_func(ext, filter);
+  return ext;
+}

data/ext/commonmarker/cmark/extensions/whitelist.h

@@ -0,0 +1,8 @@
+#ifndef WHITELIST_H
+#define WHITELIST_H
+
+#include "core-extensions.h"
+
+cmark_syntax_extension *create_whitelist_extension(void);
+
+#endif

data/ext/commonmarker/cmark/man/man3/cmark.3

@@ -1,4 +1,4 @@
-.TH cmark 3 "June 23, 2016" "LOCAL" "Library Functions Manual"
+.TH cmark 3 "September 14, 2016" "LOCAL" "Library Functions Manual"
 .SH
 NAME
 .PP
@@ -27,37 +27,31 @@ Node Structure
 .RS 0n
 typedef enum {
   /* Error status */
-  CMARK_NODE_NONE,
+  CMARK_NODE_NONE = 0x0000,
 
   /* Block */
-  CMARK_NODE_DOCUMENT,
-  CMARK_NODE_BLOCK_QUOTE,
-  CMARK_NODE_LIST,
-  CMARK_NODE_ITEM,
-  CMARK_NODE_CODE_BLOCK,
-  CMARK_NODE_HTML_BLOCK,
-  CMARK_NODE_CUSTOM_BLOCK,
-  CMARK_NODE_PARAGRAPH,
-  CMARK_NODE_HEADING,
-  CMARK_NODE_THEMATIC_BREAK,
-
-  CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT,
-  CMARK_NODE_LAST_BLOCK = CMARK_NODE_THEMATIC_BREAK,
+  CMARK_NODE_DOCUMENT       = CMARK_NODE_TYPE_BLOCK | 0x0001,
+  CMARK_NODE_BLOCK_QUOTE    = CMARK_NODE_TYPE_BLOCK | 0x0002,
+  CMARK_NODE_LIST           = CMARK_NODE_TYPE_BLOCK | 0x0003,
+  CMARK_NODE_ITEM           = CMARK_NODE_TYPE_BLOCK | 0x0004,
+  CMARK_NODE_CODE_BLOCK     = CMARK_NODE_TYPE_BLOCK | 0x0005,
+  CMARK_NODE_HTML_BLOCK     = CMARK_NODE_TYPE_BLOCK | 0x0006,
+  CMARK_NODE_CUSTOM_BLOCK   = CMARK_NODE_TYPE_BLOCK | 0x0007,
+  CMARK_NODE_PARAGRAPH      = CMARK_NODE_TYPE_BLOCK | 0x0008,
+  CMARK_NODE_HEADING        = CMARK_NODE_TYPE_BLOCK | 0x0009,
+  CMARK_NODE_THEMATIC_BREAK = CMARK_NODE_TYPE_BLOCK | 0x000a,
 
   /* Inline */
-  CMARK_NODE_TEXT,
-  CMARK_NODE_SOFTBREAK,
-  CMARK_NODE_LINEBREAK,
-  CMARK_NODE_CODE,
-  CMARK_NODE_HTML_INLINE,
-  CMARK_NODE_CUSTOM_INLINE,
-  CMARK_NODE_EMPH,
-  CMARK_NODE_STRONG,
-  CMARK_NODE_LINK,
-  CMARK_NODE_IMAGE,
-
-  CMARK_NODE_FIRST_INLINE = CMARK_NODE_TEXT,
-  CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE,
+  CMARK_NODE_TEXT          = CMARK_NODE_TYPE_INLINE | 0x0001,
+  CMARK_NODE_SOFTBREAK     = CMARK_NODE_TYPE_INLINE | 0x0002,
+  CMARK_NODE_LINEBREAK     = CMARK_NODE_TYPE_INLINE | 0x0003,
+  CMARK_NODE_CODE          = CMARK_NODE_TYPE_INLINE | 0x0004,
+  CMARK_NODE_HTML_INLINE   = CMARK_NODE_TYPE_INLINE | 0x0005,
+  CMARK_NODE_CUSTOM_INLINE = CMARK_NODE_TYPE_INLINE | 0x0006,
+  CMARK_NODE_EMPH          = CMARK_NODE_TYPE_INLINE | 0x0007,
+  CMARK_NODE_STRONG        = CMARK_NODE_TYPE_INLINE | 0x0008,
+  CMARK_NODE_LINK          = CMARK_NODE_TYPE_INLINE | 0x0009,
+  CMARK_NODE_IMAGE         = CMARK_NODE_TYPE_INLINE | 0x000a,
 } cmark_node_type;
 .RE
 \f[]
@@ -103,9 +97,9 @@ Custom memory allocator support
 \fC
 .RS 0n
 typedef struct cmark_mem {
-	void *(*calloc)(size_t, size_t);
-	void *(*realloc)(void *, size_t);
-	void (*free)(void *);
+  void *(*calloc)(size_t, size_t);
+  void *(*realloc)(void *, size_t);
+  void (*free)(void *);
 } cmark_mem;
 .RE
 \f[]
@@ -115,6 +109,45 @@ typedef struct cmark_mem {
 Defines the memory allocation functions to be used by CMark when parsing
 and allocating a document tree
 
+.SS
+Linked list
+
+.PP
+.nf
+\fC
+.RS 0n
+typedef struct _cmark_llist
+{
+  struct _cmark_llist *next;
+  void         *data;
+} cmark_llist;
+.RE
+\f[]
+.fi
+
+.PP
+A generic singly linked list.
+
+.PP
+\fIcmark_llist *\f[] \fBcmark_llist_append\f[](\fIcmark_llist       * head\f[], \fIvoid              * data\f[])
+
+.PP
+Append an element to the linked list, return the possibly modified head
+of the list.
+
+.PP
+\fIvoid\f[] \fBcmark_llist_free_full\f[](\fIcmark_llist       * head\f[], \fIcmark_free_func     free_func\f[])
+
+.PP
+Free the list starting with \f[I]head\f[], calling \f[I]free_func\f[]
+with the data pointer of each of its elements
+
+.PP
+\fIvoid\f[] \fBcmark_llist_free\f[](\fIcmark_llist       * head\f[])
+
+.PP
+Free the list starting with \f[I]head\f[]
+
 .SS
 Creating and Destroying Nodes
 
@@ -313,6 +346,12 @@ Returns the user data of \f[I]node\f[].
 Sets arbitrary user data for \f[I]node\f[]. Returns 1 on success, 0 on
 failure.
 
+.PP
+\fIint\f[] \fBcmark_node_set_user_data_free_func\f[](\fIcmark_node *node\f[], \fIcmark_free_func free_func\f[])
+
+.PP
+Set free function for user data */
+
 .PP
 \fIcmark_node_type\f[] \fBcmark_node_get_type\f[](\fIcmark_node *node\f[])
 
@@ -421,6 +460,18 @@ Returns the info string from a fenced code block.
 Sets the info string in a fenced code block, returning 1 on success
 and 0 on failure.
 
+.PP
+\fIint\f[] \fBcmark_node_set_fenced\f[](\fIcmark_node * node\f[], \fIint fenced\f[], \fIint length\f[], \fIint offset\f[], \fIchar character\f[])
+
+.PP
+Sets code blocks fencing details
+
+.PP
+\fIint\f[] \fBcmark_node_get_fenced\f[](\fIcmark_node *node\f[], \fIint *length\f[], \fIint *offset\f[], \fIchar *character\f[])
+
+.PP
+Returns code blocks fencing details
+
 .PP
 \fIconst char *\f[] \fBcmark_node_get_url\f[](\fIcmark_node *node\f[])
 
@@ -642,7 +693,7 @@ Render a \f[I]node\f[] tree as XML. It is the caller's responsibility to
 free the returned buffer.
 
 .PP
-\fIchar *\f[] \fBcmark_render_html\f[](\fIcmark_node *root\f[], \fIint options\f[])
+\fIchar *\f[] \fBcmark_render_html\f[](\fIcmark_node *root\f[], \fIint options\f[], \fIcmark_llist *extensions\f[])
 
 .PP
 Render a \f[I]node\f[] tree as an HTML fragment. It is up to the user to
@@ -740,6 +791,19 @@ HTML comment. Unsafe links are replaced by empty strings.
 .PP
 Render \f[C]softbreak\f[] elements as spaces.
 
+.PP
+.nf
+\fC
+.RS 0n
+#define CMARK_OPT_CODELANG (1 << 5)
+.RE
+\f[]
+.fi
+
+.PP
+Render code blocks' language information in the \f[C]lang' attribute of
+the\f[]pre' tag instead of a class on the `code' tag.
+
 .SS
 Options affecting parsing
 
@@ -785,7 +849,7 @@ dashes.
 Version information
 
 .PP
-\fIint\f[] \fBcmark_version\f[](\fI\f[])
+\fIint\f[] \fBcmark_version\f[](\fIvoid\f[])
 
 .PP
 The library version as integer for runtime checks. Also available as
@@ -800,7 +864,7 @@ Bits 0\-7 contain the patchlevel.
 In hexadecimal format, the number 0x010203 represents version 1.2.3.
 
 .PP
-\fIconst char *\f[] \fBcmark_version_string\f[](\fI\f[])
+\fIconst char *\f[] \fBcmark_version_string\f[](\fIvoid\f[])
 
 .PP
 The library version string for runtime checks. Also available as macro

data/ext/commonmarker/cmark/src/CMakeLists.txt

@@ -3,6 +3,7 @@ set(LIBRARY "libcmark")
 set(STATICLIBRARY "libcmark_static")
 set(HEADERS
   cmark.h
+  cmark_extension_api.h
   parser.h
   buffer.h
   node.h
@@ -15,6 +16,9 @@ set(HEADERS
   houdini.h
   cmark_ctype.h
   render.h
+  registry.h
+  syntax_extension.h
+  plugin.h
   )
 set(LIBRARY_SOURCES
   cmark.c
@@ -37,12 +41,15 @@ set(LIBRARY_SOURCES
   houdini_html_e.c
   houdini_html_u.c
   cmark_ctype.c
+  linked_list.c
+  syntax_extension.c
+  registry.c
+  plugin.c
   ${HEADERS}
   )
 
 set(PROGRAM "cmark")
 set(PROGRAM_SOURCES
-  ${LIBRARY_SOURCES}
   main.c
   )
 
@@ -70,6 +77,11 @@ include (GenerateExportHeader)
 add_executable(${PROGRAM} ${PROGRAM_SOURCES})
 add_compiler_export_flags()
 
+target_link_libraries(${PROGRAM} libcmark)
+
+add_dependencies(${PROGRAM} libcmarkextensions_static)
+target_link_libraries(${PROGRAM} libcmarkextensions_static)
+
 # Disable the PUBLIC declarations when compiling the executable:
 set_target_properties(${PROGRAM} PROPERTIES
   COMPILE_FLAGS -DCMARK_STATIC_DEFINE)
@@ -81,6 +93,8 @@ set(CMAKE_LINKER_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG}")
 set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -pg")
 set(CMAKE_LINKER_PROFILE "${CMAKE_LINKER_FLAGS_RELEASE} -pg")
 
+add_definitions(-DLIBDIR=\"${CMAKE_BINARY_DIR}\")
+
 if (${CMAKE_MAJOR_VERSION} GREATER 1 AND ${CMAKE_MINOR_VERSION} GREATER 8)
   set(CMAKE_C_VISIBILITY_PRESET hidden)
   set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
@@ -134,6 +148,7 @@ install(TARGETS ${PROGRAM} ${LIBRARY} ${STATICLIBRARY}
 
 install(FILES
   cmark.h
+  cmark_extension_api.h
   ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h
   ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h
   DESTINATION include

data/ext/commonmarker/cmark/src/blocks.c

@@ -10,6 +10,7 @@
 #include <stdio.h>
 
 #include "cmark_ctype.h"
+#include "syntax_extension.h"
 #include "config.h"
 #include "parser.h"
 #include "cmark.h"
@@ -80,30 +81,57 @@ static cmark_node *make_document(cmark_mem *mem) {
   return e;
 }
 
-cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem) {
-  cmark_parser *parser = (cmark_parser *)mem->calloc(1, sizeof(cmark_parser));
-  parser->mem = mem;
+int cmark_parser_attach_syntax_extension(cmark_parser *parser,
+                                         cmark_syntax_extension *extension) {
+  parser->syntax_extensions = cmark_llist_append(parser->syntax_extensions, extension);
+  if (extension->match_inline || extension->insert_inline_from_delim) {
+    parser->inline_syntax_extensions = cmark_llist_append(
+        parser->inline_syntax_extensions, extension);
+  }
 
-  cmark_node *document = make_document(mem);
+  return 1;
+}
+
+static void cmark_parser_dispose(cmark_parser *parser) {
+  if (parser->root)
+    cmark_node_free(parser->root);
 
-  cmark_strbuf_init(mem, &parser->curline, 256);
-  cmark_strbuf_init(mem, &parser->linebuf, 0);
+  if (parser->refmap)
+    cmark_reference_map_free(parser->refmap);
+}
 
-  parser->refmap = cmark_reference_map_new(mem);
+static void cmark_parser_reset(cmark_parser *parser) {
+  cmark_llist *saved_exts = parser->syntax_extensions;
+  cmark_llist *saved_inline_exts = parser->inline_syntax_extensions;
+  int saved_options = parser->options;
+  cmark_mem *saved_mem = parser->mem;
+
+  cmark_parser_dispose(parser);
+
+  memset(parser, 0, sizeof(cmark_parser));
+  parser->mem = saved_mem;
+
+  cmark_strbuf_init(parser->mem, &parser->curline, 256);
+  cmark_strbuf_init(parser->mem, &parser->linebuf, 0);
+
+  cmark_node *document = make_document(parser->mem);
+
+  parser->refmap = cmark_reference_map_new(parser->mem);
   parser->root = document;
   parser->current = document;
-  parser->line_number = 0;
-  parser->offset = 0;
-  parser->column = 0;
-  parser->first_nonspace = 0;
-  parser->first_nonspace_column = 0;
-  parser->indent = 0;
-  parser->blank = false;
-  parser->partially_consumed_tab = false;
-  parser->last_line_length = 0;
-  parser->options = options;
+
   parser->last_buffer_ended_with_cr = false;
 
+  parser->syntax_extensions = saved_exts;
+  parser->inline_syntax_extensions = saved_inline_exts;
+  parser->options = saved_options;
+}
+
+cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem) {
+  cmark_parser *parser = (cmark_parser *)mem->calloc(1, sizeof(cmark_parser));
+  parser->mem = mem;
+  parser->options = options;
+  cmark_parser_reset(parser);
   return parser;
 }
 
@@ -114,9 +142,11 @@ cmark_parser *cmark_parser_new(int options) {
 
 void cmark_parser_free(cmark_parser *parser) {
   cmark_mem *mem = parser->mem;
+  cmark_parser_dispose(parser);
   cmark_strbuf_free(&parser->curline);
   cmark_strbuf_free(&parser->linebuf);
-  cmark_reference_map_free(parser->refmap);
+  cmark_llist_free(parser->syntax_extensions);
+  cmark_llist_free(parser->inline_syntax_extensions);
   mem->free(parser);
 }
 
@@ -143,23 +173,19 @@ static bool is_blank(cmark_strbuf *s, bufsize_t offset) {
   return true;
 }
 
-static CMARK_INLINE bool can_contain(cmark_node_type parent_type,
-                                     cmark_node_type child_type) {
-  return (parent_type == CMARK_NODE_DOCUMENT ||
-          parent_type == CMARK_NODE_BLOCK_QUOTE ||
-          parent_type == CMARK_NODE_ITEM ||
-          (parent_type == CMARK_NODE_LIST && child_type == CMARK_NODE_ITEM));
-}
-
 static CMARK_INLINE bool accepts_lines(cmark_node_type block_type) {
   return (block_type == CMARK_NODE_PARAGRAPH ||
           block_type == CMARK_NODE_HEADING ||
           block_type == CMARK_NODE_CODE_BLOCK);
 }
 
-static CMARK_INLINE bool contains_inlines(cmark_node_type block_type) {
-  return (block_type == CMARK_NODE_PARAGRAPH ||
-          block_type == CMARK_NODE_HEADING);
+static CMARK_INLINE bool contains_inlines(cmark_node *node) {
+  if (node->extension && node->extension->contains_inlines_func) {
+    return node->extension->contains_inlines_func(node->extension, node);
+  }
+
+  return (node->type == CMARK_NODE_PARAGRAPH ||
+          node->type == CMARK_NODE_HEADING);
 }
 
 static void add_line(cmark_node *node, cmark_chunk *ch, cmark_parser *parser) {
@@ -340,7 +366,7 @@ static cmark_node *add_child(cmark_parser *parser, cmark_node *parent,
 
   // if 'parent' isn't the kind of node that can accept this child,
   // then back up til we hit a node that can.
-  while (!can_contain(S_type(parent), block_type)) {
+  while (!cmark_node_can_contain_type(parent, block_type)) {
     parent = finalize(parser, parent);
   }
 
@@ -359,23 +385,42 @@ static cmark_node *add_child(cmark_parser *parser, cmark_node *parent,
   return child;
 }
 
+static void manage_extensions_special_characters(cmark_parser *parser, bool add) {
+  cmark_llist *tmp_ext;
+
+  for (tmp_ext = parser->inline_syntax_extensions; tmp_ext; tmp_ext=tmp_ext->next) {
+    cmark_syntax_extension *ext = (cmark_syntax_extension *) tmp_ext->data;
+    cmark_llist *tmp_char;
+    for (tmp_char = ext->special_inline_chars; tmp_char; tmp_char=tmp_char->next) {
+      unsigned char c = (unsigned char) (unsigned long) tmp_char->data;
+      if (add)
+        cmark_inlines_add_special_character(c);
+      else
+        cmark_inlines_remove_special_character(c);
+    }
+  }
+}
+
 // Walk through node and all children, recursively, parsing
 // string content into inline content where appropriate.
-static void process_inlines(cmark_mem *mem, cmark_node *root,
-                            cmark_reference_map *refmap, int options) {
-  cmark_iter *iter = cmark_iter_new(root);
+static void process_inlines(cmark_parser *parser, cmark_reference_map *refmap, int options) {
+  cmark_iter *iter = cmark_iter_new(parser->root);
   cmark_node *cur;
   cmark_event_type ev_type;
 
+  manage_extensions_special_characters(parser, true);
+
   while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
     cur = cmark_iter_get_node(iter);
     if (ev_type == CMARK_EVENT_ENTER) {
-      if (contains_inlines(S_type(cur))) {
-        cmark_parse_inlines(mem, cur, refmap, options);
+      if (contains_inlines(cur)) {
+        cmark_parse_inlines(parser, cur, refmap, options);
       }
     }
   }
 
+  manage_extensions_special_characters(parser, false);
+
   cmark_iter_free(iter);
 }
 
@@ -482,7 +527,7 @@ static cmark_node *finalize_document(cmark_parser *parser) {
   }
 
   finalize(parser, parser->root);
-  process_inlines(parser->mem, parser->root, parser->refmap, parser->options);
+  process_inlines(parser, parser->refmap, parser->options);
 
   return parser->root;
 }
@@ -521,6 +566,19 @@ void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len) {
   S_parser_feed(parser, (const unsigned char *)buffer, len, false);
 }
 
+void cmark_parser_feed_reentrant(cmark_parser *parser, const char *buffer, size_t len) {
+  cmark_strbuf saved_linebuf;
+
+  cmark_strbuf_init(parser->mem, &saved_linebuf, 0);
+  cmark_strbuf_puts(&saved_linebuf, cmark_strbuf_cstr(&parser->linebuf));
+  cmark_strbuf_clear(&parser->linebuf);
+
+  S_parser_feed(parser, (const unsigned char *)buffer, len, true);
+
+  cmark_strbuf_sets(&parser->linebuf, cmark_strbuf_cstr(&saved_linebuf));
+  cmark_strbuf_free(&saved_linebuf);
+}
+
 static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
                           size_t len, bool eof) {
   const unsigned char *end = buffer + len;
@@ -778,6 +836,21 @@ static bool parse_html_block_prefix(cmark_parser *parser,
   return res;
 }
 
+static bool parse_extension_block(cmark_parser *parser,
+                                  cmark_node *container,
+                                  cmark_chunk *input)
+{
+  bool res = false;
+
+  if (container->extension->last_block_matches) {
+    if (container->extension->last_block_matches(
+        container->extension, parser, input->data, input->len, container))
+      res = true;
+  }
+
+  return res;
+}
+
 /**
  * For each containing node, try to parse the associated line start.
  *
@@ -799,6 +872,12 @@ static cmark_node *check_open_blocks(cmark_parser *parser, cmark_chunk *input,
 
     S_find_first_nonspace(parser, input);
 
+    if (container->extension) {
+      if (!parse_extension_block(parser, container, input))
+        goto done;
+      continue;
+    }
+
     switch (cont_type) {
     case CMARK_NODE_BLOCK_QUOTE:
       if (!parse_block_quote_prefix(parser, input))
@@ -999,9 +1078,27 @@ static void open_new_blocks(cmark_parser *parser, cmark_node **container,
       (*container)->as.code.fence_length = 0;
       (*container)->as.code.fence_offset = 0;
       (*container)->as.code.info = cmark_chunk_literal("");
-
     } else {
-      break;
+      cmark_llist *tmp;
+      cmark_node *new_container = NULL;
+
+      for (tmp = parser->syntax_extensions; tmp; tmp=tmp->next) {
+        cmark_syntax_extension *ext = (cmark_syntax_extension *) tmp->data;
+
+        if (ext->try_opening_block) {
+          new_container = ext->try_opening_block(
+              ext, indented, parser, *container, input->data, input->len);
+
+          if (new_container) {
+            *container = new_container;
+            break;
+          }
+        }
+      }
+
+      if (!new_container) {
+        break;
+      }
     }
 
     if (accepts_lines(S_type(*container))) {
@@ -1134,6 +1231,9 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
   bool all_matched = true;
   cmark_node *container;
   cmark_chunk input;
+  cmark_node *current;
+
+  cmark_strbuf_clear(&parser->curline);
 
   if (parser->options & CMARK_OPT_VALIDATE_UTF8)
     cmark_utf8proc_check(&parser->curline, buffer, bytes);
@@ -1161,9 +1261,13 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
 
   container = last_matched_container;
 
+  current = parser->current;
+
   open_new_blocks(parser, &container, &input, all_matched);
 
-  add_text_to_container(parser, container, last_matched_container, &input);
+  /* parser->current might have changed if feed_reentrant was called */
+  if (current == parser->current)
+    add_text_to_container(parser, container, last_matched_container, &input);
 
 finished:
   parser->last_line_length = input.len;
@@ -1178,6 +1282,13 @@ finished:
 }
 
 cmark_node *cmark_parser_finish(cmark_parser *parser) {
+  cmark_node *res;
+  cmark_llist *extensions;
+
+  /* Parser was already finished once */
+  if (parser->root == NULL)
+    return NULL;
+
   if (parser->linebuf.size) {
     S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size);
     cmark_strbuf_clear(&parser->linebuf);
@@ -1190,11 +1301,79 @@ cmark_node *cmark_parser_finish(cmark_parser *parser) {
   }
 
   cmark_strbuf_free(&parser->curline);
+  cmark_strbuf_free(&parser->linebuf);
 
 #if CMARK_DEBUG_NODES
   if (cmark_node_check(parser->root, stderr)) {
     abort();
   }
 #endif
-  return parser->root;
+
+  res = parser->root;
+  parser->root = NULL;
+
+  cmark_parser_reset(parser);
+
+  for (extensions = parser->syntax_extensions; extensions; extensions = extensions->next) {
+    cmark_syntax_extension *ext = (cmark_syntax_extension *) extensions->data;
+    if (ext->postprocess_func) {
+      cmark_node *processed = ext->postprocess_func(ext, res);
+      if (processed)
+        res = processed;
+    }
+  }
+
+  return res;
+}
+
+int cmark_parser_get_line_number(cmark_parser *parser) {
+  return parser->line_number;
+}
+
+bufsize_t cmark_parser_get_offset(cmark_parser *parser) {
+  return parser->offset;
+}
+
+bufsize_t cmark_parser_get_column(cmark_parser *parser) {
+  return parser->column;
+}
+
+int cmark_parser_get_first_nonspace(cmark_parser *parser) {
+  return parser->first_nonspace;
+}
+
+int cmark_parser_get_first_nonspace_column(cmark_parser *parser) {
+  return parser->first_nonspace_column;
+}
+
+int cmark_parser_get_indent(cmark_parser *parser) {
+  return parser->indent;
+}
+
+int cmark_parser_is_blank(cmark_parser *parser) {
+  return parser->blank;
+}
+
+int cmark_parser_has_partially_consumed_tab(cmark_parser *parser) {
+  return parser->partially_consumed_tab;
+}
+
+int cmark_parser_get_last_line_length(cmark_parser *parser) {
+  return parser->last_line_length;
+}
+
+cmark_node *cmark_parser_add_child(cmark_parser *parser,
+                                   cmark_node   *parent,
+                                   cmark_node_type block_type,
+                                   int start_column) {
+  return add_child(parser, parent, block_type, start_column);
+}
+
+void cmark_parser_advance_offset(cmark_parser *parser,
+                                 const char *input,
+                                 int count,
+                                 int columns) {
+  cmark_chunk input_chunk = cmark_chunk_literal(input);
+
+  S_advance_offset(parser, &input_chunk, count, columns);
 }