commonmarker 0.9.1 → 0.9.2

data/ext/commonmarker/cmark/build/testdir/cmake_install.cmake

@@ -0,0 +1,29 @@
+# Install script for directory: /Users/gjtorikian/Development/commonmarker/ext/commonmarker/cmark/test
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/usr/local")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+

data/ext/commonmarker/cmark/man/man1/cmark.1

@@ -25,13 +25,20 @@ Specify a column width to which to wrap the output. For no wrapping, use
 the value 0 (the default).  This option currently only affects the
 commonmark, latex, and man renderers.
 .TP 12n
+.B \-\-hardbreaks
+Render soft breaks (newlines inside paragraphs in the CommonMark source)
+as hard line breaks in the target format.  If this option is specified,
+hard wrapping is disabled for CommonMark output, regardless of the value
+given with \-\-width.
+.TP 12n
+.B \-\-nobreaks
+Render soft breaks as spaces.  If this option is specified,
+hard wrapping is disabled for all output formats, regardless of the value
+given with \-\-width.
+.TP 12n
 .B \-\-sourcepos
 Include source position attribute.
 .TP 12n
-.B \-\-hardbreaks
-Treat newlines as hard line breaks.  If this option is specified,
-hard wrapping is disabled, regardless of the value given with \-\-width.
-.TP 12n
 .B \-\-normalize
 Consolidate adjacent text nodes.
 .TP 12n

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

@@ -1,4 +1,4 @@
-.TH cmark 3 "March 24, 2016" "LOCAL" "Library Functions Manual"
+.TH cmark 3 "June 06, 2016" "LOCAL" "Library Functions Manual"
 .SH
 NAME
 .PP
@@ -15,7 +15,8 @@ Simple Interface
 .PP
 Convert \f[I]text\f[] (assumed to be a UTF\-8 encoded string with length
 \f[I]len\f[]) from CommonMark Markdown to HTML, returning a
-null\-terminated, UTF\-8\-encoded string.
+null\-terminated, UTF\-8\-encoded string. It is the caller\[cq]s
+responsibility to free the returned buffer.
 
 .SS
 Node Structure
@@ -94,6 +95,26 @@ typedef enum {
 
 
 
+.SS
+Custom memory allocator support
+
+.PP
+.nf
+\fC
+.RS 0n
+typedef struct cmark_mem {
+	void *(*calloc)(size_t, size_t);
+	void *(*realloc)(void *, size_t);
+	void (*free)(void *);
+} cmark_mem;
+.RE
+\f[]
+.fi
+
+.PP
+Defines the memory allocation functions to be used by CMark when parsing
+and allocating a document tree
+
 .SS
 Creating and Destroying Nodes
 
@@ -105,6 +126,13 @@ Creates a new node of type \f[I]type\f[]. Note that the node may have
 other required properties, which it is the caller\[cq]s responsibility
 to assign.
 
+.PP
+\fIcmark_node *\f[] \fBcmark_node_new_with_mem\f[](\fIcmark_node_type type\f[], \fIcmark_mem *mem\f[])
+
+.PP
+Same as \f[C]cmark_node_new\f[], but explicitly listing the memory
+allocator used to allocate the node
+
 .PP
 \fIvoid\f[] \fBcmark_node_free\f[](\fIcmark_node *node\f[])
 
@@ -224,8 +252,9 @@ typedef enum {
 
 .PP
 Creates a new iterator starting at \f[I]root\f[]. The current node and
-event type are undefined until \f[C]cmark_iter_next\f[] is called for
-the first time.
+event type are undefined until \f[I]cmark_iter_next\f[] is called for
+the first time. The memory allocated for the iterator should be released
+using \f[I]cmark_iter_free\f[] when it is no longer needed.
 
 .PP
 \fIvoid\f[] \fBcmark_iter_free\f[](\fIcmark_iter *iter\f[])
@@ -561,6 +590,12 @@ cmark_parser_free(parser);
 .PP
 Creates a new parser object.
 
+.PP
+\fIcmark_parser *\f[] \fBcmark_parser_new_with_mem\f[](\fIint options\f[], \fIcmark_mem *mem\f[])
+
+.PP
+Creates a new parser object with the given memory allocator
+
 .PP
 \fIvoid\f[] \fBcmark_parser_free\f[](\fIcmark_parser *parser\f[])
 
@@ -584,14 +619,17 @@ Finish parsing and return a pointer to a tree of nodes.
 
 .PP
 Parse a CommonMark document in \f[I]buffer\f[] of length \f[I]len\f[].
-Returns a pointer to a tree of nodes.
+Returns a pointer to a tree of nodes. The memory allocated for the node
+tree should be released using \f[I]cmark_node_free\f[] when it is no
+longer needed.
 
 .PP
 \fIcmark_node *\f[] \fBcmark_parse_file\f[](\fIFILE *f\f[], \fIint options\f[])
 
 .PP
 Parse a CommonMark document in file \f[I]f\f[], returning a pointer to a
-tree of nodes.
+tree of nodes. The memory allocated for the node tree should be released
+using \f[I]cmark_node_free\f[] when it is no longer needed.
 
 .SS
 Rendering
@@ -600,32 +638,37 @@ Rendering
 \fIchar *\f[] \fBcmark_render_xml\f[](\fIcmark_node *root\f[], \fIint options\f[])
 
 .PP
-Render a \f[I]node\f[] tree as XML.
+Render a \f[I]node\f[] tree as XML. It is the caller\[cq]s
+responsibility to free the returned buffer.
 
 .PP
 \fIchar *\f[] \fBcmark_render_html\f[](\fIcmark_node *root\f[], \fIint options\f[])
 
 .PP
 Render a \f[I]node\f[] tree as an HTML fragment. It is up to the user to
-add an appropriate header and footer.
+add an appropriate header and footer. It is the caller\[cq]s
+responsibility to free the returned buffer.
 
 .PP
 \fIchar *\f[] \fBcmark_render_man\f[](\fIcmark_node *root\f[], \fIint options\f[], \fIint width\f[])
 
 .PP
-Render a \f[I]node\f[] tree as a groff man page, without the header.
+Render a \f[I]node\f[] tree as a groff man page, without the header. It
+is the caller\[cq]s responsibility to free the returned buffer.
 
 .PP
 \fIchar *\f[] \fBcmark_render_commonmark\f[](\fIcmark_node *root\f[], \fIint options\f[], \fIint width\f[])
 
 .PP
-Render a \f[I]node\f[] tree as a commonmark document.
+Render a \f[I]node\f[] tree as a commonmark document. It is the
+caller\[cq]s responsibility to free the returned buffer.
 
 .PP
 \fIchar *\f[] \fBcmark_render_latex\f[](\fIcmark_node *root\f[], \fIint options\f[], \fIint width\f[])
 
 .PP
-Render a \f[I]node\f[] tree as a LaTeX document.
+Render a \f[I]node\f[] tree as a LaTeX document. It is the caller\[cq]s
+responsibility to free the returned buffer.
 
 .SS
 Options
@@ -685,6 +728,18 @@ Suppress raw HTML and unsafe links (\f[C]javascript:\f[],
 \f[C]image/webp\f[] mime types). Raw HTML is replaced by a placeholder
 HTML comment. Unsafe links are replaced by empty strings.
 
+.PP
+.nf
+\fC
+.RS 0n
+#define CMARK_OPT_NOBREAKS (1 << 4)
+.RE
+\f[]
+.fi
+
+.PP
+Render \f[C]softbreak\f[] elements as spaces.
+
 .SS
 Options affecting parsing
 

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

@@ -30,6 +30,21 @@
 
 #define peek_at(i, n) (i)->data[n]
 
+static bool S_last_line_blank(const cmark_node *node) {
+  return (node->flags & CMARK_NODE__LAST_LINE_BLANK) != 0;
+}
+
+static CMARK_INLINE cmark_node_type S_type(const cmark_node *node) {
+  return (cmark_node_type)node->type;
+}
+
+static void S_set_last_line_blank(cmark_node *node, bool is_blank) {
+  if (is_blank)
+    node->flags |= CMARK_NODE__LAST_LINE_BLANK;
+  else
+    node->flags &= ~CMARK_NODE__LAST_LINE_BLANK;
+}
+
 static CMARK_INLINE bool S_is_line_end_char(char c) {
   return (c == '\n' || c == '\r');
 }
@@ -44,38 +59,37 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
 static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
                            bufsize_t bytes);
 
-static cmark_node *make_block(cmark_node_type tag, int start_line,
+static cmark_node *make_block(cmark_mem *mem, cmark_node_type tag, int start_line,
                               int start_column) {
   cmark_node *e;
 
-  e = (cmark_node *)calloc(1, sizeof(*e));
-  if (e != NULL) {
-    e->type = tag;
-    e->open = true;
-    e->start_line = start_line;
-    e->start_column = start_column;
-    e->end_line = start_line;
-    cmark_strbuf_init(&e->string_content, 32);
-  }
+  e = (cmark_node *)mem->calloc(1, sizeof(*e));
+  cmark_strbuf_init(mem, &e->content, 32);
+  e->type = (uint16_t)tag;
+  e->flags = CMARK_NODE__OPEN;
+  e->start_line = start_line;
+  e->start_column = start_column;
+  e->end_line = start_line;
 
   return e;
 }
 
 // Create a root document node.
-static cmark_node *make_document() {
-  cmark_node *e = make_block(CMARK_NODE_DOCUMENT, 1, 1);
+static cmark_node *make_document(cmark_mem *mem) {
+  cmark_node *e = make_block(mem, CMARK_NODE_DOCUMENT, 1, 1);
   return e;
 }
 
-cmark_parser *cmark_parser_new(int options) {
-  cmark_parser *parser = (cmark_parser *)malloc(sizeof(cmark_parser));
-  cmark_node *document = make_document();
-  cmark_strbuf *line = (cmark_strbuf *)malloc(sizeof(cmark_strbuf));
-  cmark_strbuf *buf = (cmark_strbuf *)malloc(sizeof(cmark_strbuf));
-  cmark_strbuf_init(line, 256);
-  cmark_strbuf_init(buf, 0);
-
-  parser->refmap = cmark_reference_map_new();
+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;
+
+  cmark_node *document = make_document(mem);
+
+  cmark_strbuf_init(mem, &parser->curline, 256);
+  cmark_strbuf_init(mem, &parser->linebuf, 0);
+
+  parser->refmap = cmark_reference_map_new(mem);
   parser->root = document;
   parser->current = document;
   parser->line_number = 0;
@@ -86,22 +100,24 @@ cmark_parser *cmark_parser_new(int options) {
   parser->indent = 0;
   parser->blank = false;
   parser->partially_consumed_tab = false;
-  parser->curline = line;
   parser->last_line_length = 0;
-  parser->linebuf = buf;
   parser->options = options;
   parser->last_buffer_ended_with_cr = false;
 
   return parser;
 }
 
+cmark_parser *cmark_parser_new(int options) {
+  extern cmark_mem DEFAULT_MEM_ALLOCATOR;
+  return cmark_parser_new_with_mem(options, &DEFAULT_MEM_ALLOCATOR);
+}
+
 void cmark_parser_free(cmark_parser *parser) {
-  cmark_strbuf_free(parser->curline);
-  free(parser->curline);
-  cmark_strbuf_free(parser->linebuf);
-  free(parser->linebuf);
+  cmark_mem *mem = parser->mem;
+  cmark_strbuf_free(&parser->curline);
+  cmark_strbuf_free(&parser->linebuf);
   cmark_reference_map_free(parser->refmap);
-  free(parser);
+  mem->free(parser);
 }
 
 static cmark_node *finalize(cmark_parser *parser, cmark_node *b);
@@ -128,7 +144,7 @@ static bool is_blank(cmark_strbuf *s, bufsize_t offset) {
 }
 
 static CMARK_INLINE bool can_contain(cmark_node_type parent_type,
-                               cmark_node_type child_type) {
+                                     cmark_node_type child_type) {
   return (parent_type == CMARK_NODE_DOCUMENT ||
           parent_type == CMARK_NODE_BLOCK_QUOTE ||
           parent_type == CMARK_NODE_ITEM ||
@@ -149,18 +165,17 @@ static CMARK_INLINE bool contains_inlines(cmark_node_type block_type) {
 static void add_line(cmark_node *node, cmark_chunk *ch, cmark_parser *parser) {
   int chars_to_tab;
   int i;
-  assert(node->open);
+  assert(node->flags & CMARK_NODE__OPEN);
   if (parser->partially_consumed_tab) {
     parser->offset += 1; // skip over tab
     // add space characters:
     chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);
     for (i = 0; i < chars_to_tab; i++) {
-      cmark_strbuf_putc(&node->string_content, ' ');
+      cmark_strbuf_putc(&node->content, ' ');
     }
   }
-  cmark_strbuf_put(&node->string_content,
-		  ch->data + parser->offset,
-		  ch->len - parser->offset);
+  cmark_strbuf_put(&node->content, ch->data + parser->offset,
+                   ch->len - parser->offset);
 }
 
 static void remove_trailing_blank_lines(cmark_strbuf *ln) {
@@ -195,10 +210,10 @@ static void remove_trailing_blank_lines(cmark_strbuf *ln) {
 static bool ends_with_blank_line(cmark_node *node) {
   cmark_node *cur = node;
   while (cur != NULL) {
-    if (cur->last_line_blank) {
+    if (S_last_line_blank(cur)) {
       return true;
     }
-    if (cur->type == CMARK_NODE_LIST || cur->type == CMARK_NODE_ITEM) {
+    if (S_type(cur) == CMARK_NODE_LIST || S_type(cur) == CMARK_NODE_ITEM) {
       cur = cur->last_child;
     } else {
       cur = NULL;
@@ -212,7 +227,7 @@ static int break_out_of_lists(cmark_parser *parser, cmark_node **bptr) {
   cmark_node *container = *bptr;
   cmark_node *b = parser->root;
   // find first containing NODE_LIST:
-  while (b && b->type != CMARK_NODE_LIST) {
+  while (b && S_type(b) != CMARK_NODE_LIST) {
     b = b->last_child;
   }
   if (b) {
@@ -232,37 +247,38 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {
   cmark_node *parent;
 
   parent = b->parent;
+  assert(b->flags & CMARK_NODE__OPEN); // shouldn't call finalize on closed blocks
+  b->flags &= ~CMARK_NODE__OPEN;
 
-  assert(b->open); // shouldn't call finalize on closed blocks
-  b->open = false;
-
-  if (parser->curline->size == 0) {
+  if (parser->curline.size == 0) {
     // end of input - line number has not been incremented
     b->end_line = parser->line_number;
     b->end_column = parser->last_line_length;
-  } else if (b->type == CMARK_NODE_DOCUMENT ||
-             (b->type == CMARK_NODE_CODE_BLOCK && b->as.code.fenced) ||
-             (b->type == CMARK_NODE_HEADING && b->as.heading.setext)) {
+  } else if (S_type(b) == CMARK_NODE_DOCUMENT ||
+             (S_type(b) == CMARK_NODE_CODE_BLOCK && b->as.code.fenced) ||
+             (S_type(b) == CMARK_NODE_HEADING && b->as.heading.setext)) {
     b->end_line = parser->line_number;
-    b->end_column = parser->curline->size;
-    if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\n')
+    b->end_column = parser->curline.size;
+    if (b->end_column && parser->curline.ptr[b->end_column - 1] == '\n')
       b->end_column -= 1;
-    if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\r')
+    if (b->end_column && parser->curline.ptr[b->end_column - 1] == '\r')
       b->end_column -= 1;
   } else {
     b->end_line = parser->line_number - 1;
     b->end_column = parser->last_line_length;
   }
 
-  switch (b->type) {
+  cmark_strbuf *node_content = &b->content;
+
+  switch (S_type(b)) {
   case CMARK_NODE_PARAGRAPH:
-    while (cmark_strbuf_at(&b->string_content, 0) == '[' &&
-           (pos = cmark_parse_reference_inline(&b->string_content,
+    while (cmark_strbuf_at(node_content, 0) == '[' &&
+           (pos = cmark_parse_reference_inline(parser->mem, node_content,
                                                parser->refmap))) {
 
-      cmark_strbuf_drop(&b->string_content, pos);
+      cmark_strbuf_drop(node_content, pos);
     }
-    if (is_blank(&b->string_content, 0)) {
+    if (is_blank(node_content, 0)) {
       // remove blank node (former reference def)
       cmark_node_free(b);
     }
@@ -270,34 +286,33 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {
 
   case CMARK_NODE_CODE_BLOCK:
     if (!b->as.code.fenced) { // indented code
-      remove_trailing_blank_lines(&b->string_content);
-      cmark_strbuf_putc(&b->string_content, '\n');
+      remove_trailing_blank_lines(node_content);
+      cmark_strbuf_putc(node_content, '\n');
     } else {
-
       // first line of contents becomes info
-      for (pos = 0; pos < b->string_content.size; ++pos) {
-        if (S_is_line_end_char(b->string_content.ptr[pos]))
+      for (pos = 0; pos < node_content->size; ++pos) {
+        if (S_is_line_end_char(node_content->ptr[pos]))
           break;
       }
-      assert(pos < b->string_content.size);
+      assert(pos < node_content->size);
 
-      cmark_strbuf tmp = GH_BUF_INIT;
-      houdini_unescape_html_f(&tmp, b->string_content.ptr, pos);
+      cmark_strbuf tmp = CMARK_BUF_INIT(parser->mem);
+      houdini_unescape_html_f(&tmp, node_content->ptr, pos);
       cmark_strbuf_trim(&tmp);
       cmark_strbuf_unescape(&tmp);
       b->as.code.info = cmark_chunk_buf_detach(&tmp);
 
-      if (b->string_content.ptr[pos] == '\r')
+      if (node_content->ptr[pos] == '\r')
         pos += 1;
-      if (b->string_content.ptr[pos] == '\n')
+      if (node_content->ptr[pos] == '\n')
         pos += 1;
-      cmark_strbuf_drop(&b->string_content, pos);
+      cmark_strbuf_drop(node_content, pos);
     }
-    b->as.code.literal = cmark_chunk_buf_detach(&b->string_content);
+    b->as.code.literal = cmark_chunk_buf_detach(node_content);
     break;
 
   case CMARK_NODE_HTML_BLOCK:
-    b->as.literal = cmark_chunk_buf_detach(&b->string_content);
+    b->as.literal = cmark_chunk_buf_detach(node_content);
     break;
 
   case CMARK_NODE_LIST:      // determine tight/loose status
@@ -306,7 +321,7 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {
 
     while (item) {
       // check for non-final non-empty list item ending with blank line:
-      if (item->last_line_blank && item->next) {
+      if (S_last_line_blank(item) && item->next) {
         b->as.list.tight = false;
         break;
       }
@@ -331,6 +346,7 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {
   default:
     break;
   }
+
   return parent;
 }
 
@@ -341,11 +357,11 @@ 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(parent->type, block_type)) {
+  while (!can_contain(S_type(parent), block_type)) {
     parent = finalize(parser, parent);
   }
 
-  cmark_node *child = make_block(block_type, parser->line_number, start_column);
+  cmark_node *child = make_block(parser->mem, block_type, parser->line_number, start_column);
   child->parent = parent;
 
   if (parent->last_child) {
@@ -361,7 +377,7 @@ static cmark_node *add_child(cmark_parser *parser, cmark_node *parent,
 
 // Walk through node and all children, recursively, parsing
 // string content into inline content where appropriate.
-static void process_inlines(cmark_node *root, cmark_reference_map *refmap,
+static void process_inlines(cmark_mem *mem, cmark_node *root, cmark_reference_map *refmap,
                             int options) {
   cmark_iter *iter = cmark_iter_new(root);
   cmark_node *cur;
@@ -370,8 +386,8 @@ static void process_inlines(cmark_node *root, cmark_reference_map *refmap,
   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(cur->type)) {
-        cmark_parse_inlines(cur, refmap, options);
+      if (contains_inlines(S_type(cur))) {
+        cmark_parse_inlines(mem, cur, refmap, options);
       }
     }
   }
@@ -382,7 +398,7 @@ static void process_inlines(cmark_node *root, cmark_reference_map *refmap,
 // Attempts to parse a list item marker (bullet or enumerated).
 // On success, returns length of the marker, and populates
 // data with the details.  On failure, returns 0.
-static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos,
+static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input, bufsize_t pos,
                                    cmark_list **dataptr) {
   unsigned char c;
   bufsize_t startpos;
@@ -396,17 +412,13 @@ static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos,
     if (!cmark_isspace(peek_at(input, pos))) {
       return 0;
     }
-    data = (cmark_list *)calloc(1, sizeof(*data));
-    if (data == NULL) {
-      return 0;
-    } else {
-      data->marker_offset = 0; // will be adjusted later
-      data->list_type = CMARK_BULLET_LIST;
-      data->bullet_char = c;
-      data->start = 1;
-      data->delimiter = CMARK_PERIOD_DELIM;
-      data->tight = false;
-    }
+    data = (cmark_list *)mem->calloc(1, sizeof(*data));
+    data->marker_offset = 0; // will be adjusted later
+    data->list_type = CMARK_BULLET_LIST;
+    data->bullet_char = c;
+    data->start = 1;
+    data->delimiter = CMARK_PERIOD_DELIM;
+    data->tight = false;
   } else if (cmark_isdigit(c)) {
     int start = 0;
     int digits = 0;
@@ -426,21 +438,16 @@ static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos,
       if (!cmark_isspace(peek_at(input, pos))) {
         return 0;
       }
-      data = (cmark_list *)calloc(1, sizeof(*data));
-      if (data == NULL) {
-        return 0;
-      } else {
-        data->marker_offset = 0; // will be adjusted later
-        data->list_type = CMARK_ORDERED_LIST;
-        data->bullet_char = 0;
-        data->start = start;
-        data->delimiter = (c == '.' ? CMARK_PERIOD_DELIM : CMARK_PAREN_DELIM);
-        data->tight = false;
-      }
+      data = (cmark_list *)mem->calloc(1, sizeof(*data));
+      data->marker_offset = 0; // will be adjusted later
+      data->list_type = CMARK_ORDERED_LIST;
+      data->bullet_char = 0;
+      data->start = start;
+      data->delimiter = (c == '.' ? CMARK_PERIOD_DELIM : CMARK_PAREN_DELIM);
+      data->tight = false;
     } else {
       return 0;
     }
-
   } else {
     return 0;
   }
@@ -463,7 +470,7 @@ static cmark_node *finalize_document(cmark_parser *parser) {
   }
 
   finalize(parser, parser->root);
-  process_inlines(parser->root, parser->refmap, parser->options);
+  process_inlines(parser->mem, parser->root, parser->refmap, parser->options);
 
   return parser->root;
 }
@@ -529,24 +536,24 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
       process = true;
     }
 
-    chunk_len = cmark_strbuf_check_bufsize(eol - buffer);
+    chunk_len = (eol - buffer);
     if (process) {
-      if (parser->linebuf->size > 0) {
-        cmark_strbuf_put(parser->linebuf, buffer, chunk_len);
-        S_process_line(parser, parser->linebuf->ptr, parser->linebuf->size);
-        cmark_strbuf_clear(parser->linebuf);
+      if (parser->linebuf.size > 0) {
+        cmark_strbuf_put(&parser->linebuf, buffer, chunk_len);
+        S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size);
+        cmark_strbuf_clear(&parser->linebuf);
       } else {
         S_process_line(parser, buffer, chunk_len);
       }
     } else {
       if (eol < end && *eol == '\0') {
         // omit NULL byte
-        cmark_strbuf_put(parser->linebuf, buffer, chunk_len);
+        cmark_strbuf_put(&parser->linebuf, buffer, chunk_len);
         // add replacement character
-        cmark_strbuf_put(parser->linebuf, repl, 3);
+        cmark_strbuf_put(&parser->linebuf, repl, 3);
         chunk_len += 1; // so we advance the buffer past NULL
       } else {
-        cmark_strbuf_put(parser->linebuf, buffer, chunk_len);
+        cmark_strbuf_put(&parser->linebuf, buffer, chunk_len);
       }
     }
 
@@ -555,7 +562,7 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
     if (buffer < end && *buffer == '\r') {
       buffer++;
       if (buffer == end)
-	parser->last_buffer_ended_with_cr = true;
+        parser->last_buffer_ended_with_cr = true;
     }
     if (buffer < end && *buffer == '\n')
       buffer++;
@@ -627,16 +634,16 @@ static void S_advance_offset(cmark_parser *parser, cmark_chunk *input,
     if (c == '\t') {
       chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);
       if (columns) {
-	parser->partially_consumed_tab = chars_to_tab > count;
-	chars_to_advance = MIN(count, chars_to_tab);
-	parser->column += chars_to_advance;
+        parser->partially_consumed_tab = chars_to_tab > count;
+        chars_to_advance = MIN(count, chars_to_tab);
+        parser->column += chars_to_advance;
         parser->offset += (parser->partially_consumed_tab ? 0 : 1);
-	count -= chars_to_advance;
+        count -= chars_to_advance;
       } else {
-	parser->partially_consumed_tab = false;
-	parser->column += chars_to_tab;
-	parser->offset += 1;
-	count -= 1;
+        parser->partially_consumed_tab = false;
+        parser->column += chars_to_tab;
+        parser->offset += 1;
+        count -= 1;
       }
     } else {
       parser->partially_consumed_tab = false;
@@ -648,12 +655,10 @@ static void S_advance_offset(cmark_parser *parser, cmark_chunk *input,
 }
 
 static bool S_last_child_is_open(cmark_node *container) {
-  return container->last_child && container->last_child->open;
+  return container->last_child && (container->last_child->flags & CMARK_NODE__OPEN);
 }
 
-static bool parse_block_quote_prefix(cmark_parser *parser,
-                                cmark_chunk *input)
-{
+static bool parse_block_quote_prefix(cmark_parser *parser, cmark_chunk *input) {
   bool res = false;
   bufsize_t matched = 0;
 
@@ -672,34 +677,30 @@ static bool parse_block_quote_prefix(cmark_parser *parser,
   return res;
 }
 
-static bool parse_node_item_prefix(cmark_parser *parser,
-                              cmark_chunk *input,
-                              cmark_node *container)
-{
+static bool parse_node_item_prefix(cmark_parser *parser, cmark_chunk *input,
+                                   cmark_node *container) {
   bool res = false;
 
   if (parser->indent >=
       container->as.list.marker_offset + container->as.list.padding) {
     S_advance_offset(parser, input, container->as.list.marker_offset +
-                                         container->as.list.padding,
+                                        container->as.list.padding,
                      true);
     res = true;
   } else if (parser->blank && container->first_child != NULL) {
     // if container->first_child is NULL, then the opening line
     // of the list item was blank after the list marker; in this
     // case, we are done with the list item.
-    S_advance_offset(parser, input,
-                     parser->first_nonspace - parser->offset, false);
+    S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+                     false);
     res = true;
   }
   return res;
 }
 
-static bool parse_code_block_prefix(cmark_parser *parser,
-                               cmark_chunk *input,
-                               cmark_node *container,
-                               bool *should_continue)
-{
+static bool parse_code_block_prefix(cmark_parser *parser, cmark_chunk *input,
+                                    cmark_node *container,
+                                    bool *should_continue) {
   bool res = false;
 
   if (!container->as.code.fenced) { // indented
@@ -707,8 +708,8 @@ static bool parse_code_block_prefix(cmark_parser *parser,
       S_advance_offset(parser, input, CODE_INDENT, true);
       res = true;
     } else if (parser->blank) {
-      S_advance_offset(parser, input,
-                       parser->first_nonspace - parser->offset, false);
+      S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+                       false);
       res = true;
     }
   } else { // fenced
@@ -741,25 +742,24 @@ static bool parse_code_block_prefix(cmark_parser *parser,
 }
 
 static bool parse_html_block_prefix(cmark_parser *parser,
-                               cmark_node *container)
-{
+                                    cmark_node *container) {
   bool res = false;
   int html_block_type = container->as.html_block_type;
 
   assert(html_block_type >= 1 && html_block_type <= 7);
   switch (html_block_type) {
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-    case 5:
-      // these types of blocks can accept blanks
-      res = true;
-      break;
-    case 6:
-    case 7:
-      res = !parser->blank;
-      break;
+  case 1:
+  case 2:
+  case 3:
+  case 4:
+  case 5:
+    // these types of blocks can accept blanks
+    res = true;
+    break;
+  case 6:
+  case 7:
+    res = !parser->blank;
+    break;
   }
 
   return res;
@@ -773,10 +773,8 @@ static bool parse_html_block_prefix(cmark_parser *parser,
  *
  * Returns: The last matching node, or NULL
  */
-static cmark_node *check_open_blocks(cmark_parser *parser,
-                                     cmark_chunk *input,
-                                     bool *all_matched)
-{
+static cmark_node *check_open_blocks(cmark_parser *parser, cmark_chunk *input,
+                                     bool *all_matched) {
   bool should_continue = true;
   *all_matched = false;
   cmark_node *container = parser->root;
@@ -784,36 +782,36 @@ static cmark_node *check_open_blocks(cmark_parser *parser,
 
   while (S_last_child_is_open(container)) {
     container = container->last_child;
-    cont_type = container->type;
+    cont_type = S_type(container);
 
     S_find_first_nonspace(parser, input);
 
     switch (cont_type) {
-      case CMARK_NODE_BLOCK_QUOTE:
-        if (!parse_block_quote_prefix(parser, input))
-          goto done;
-        break;
-      case CMARK_NODE_ITEM:
-        if (!parse_node_item_prefix(parser, input, container))
-          goto done;
-        break;
-      case CMARK_NODE_CODE_BLOCK:
-        if (!parse_code_block_prefix(parser, input, container, &should_continue))
-          goto done;
-        break;
-      case CMARK_NODE_HEADING:
-        // a heading can never contain more than one line
+    case CMARK_NODE_BLOCK_QUOTE:
+      if (!parse_block_quote_prefix(parser, input))
         goto done;
-      case CMARK_NODE_HTML_BLOCK:
-        if (!parse_html_block_prefix(parser, container))
-          goto done;
-        break;
-      case CMARK_NODE_PARAGRAPH:
-        if (parser->blank)
-          goto done;
-        break;
-      default:
-        break;
+      break;
+    case CMARK_NODE_ITEM:
+      if (!parse_node_item_prefix(parser, input, container))
+        goto done;
+      break;
+    case CMARK_NODE_CODE_BLOCK:
+      if (!parse_code_block_prefix(parser, input, container, &should_continue))
+        goto done;
+      break;
+    case CMARK_NODE_HEADING:
+      // a heading can never contain more than one line
+      goto done;
+    case CMARK_NODE_HTML_BLOCK:
+      if (!parse_html_block_prefix(parser, container))
+        goto done;
+      break;
+    case CMARK_NODE_PARAGRAPH:
+      if (parser->blank)
+        goto done;
+      break;
+    default:
+      break;
     }
   }
 
@@ -831,15 +829,12 @@ done:
   return container;
 }
 
-static void open_new_blocks(cmark_parser *parser,
-                            cmark_node **container,
-                            cmark_chunk *input,
-                            bool all_matched)
-{
+static void open_new_blocks(cmark_parser *parser, cmark_node **container,
+                            cmark_chunk *input, bool all_matched) {
   bool indented;
   cmark_list *data = NULL;
-  bool maybe_lazy = parser->current->type == CMARK_NODE_PARAGRAPH;
-  cmark_node_type cont_type = (*container)->type;
+  bool maybe_lazy = S_type(parser->current) == CMARK_NODE_PARAGRAPH;
+  cmark_node_type cont_type = S_type(*container);
   bufsize_t matched = 0;
   int lev = 0;
   bool save_partially_consumed_tab;
@@ -861,7 +856,7 @@ static void open_new_blocks(cmark_parser *parser,
         S_advance_offset(parser, input, 1, true);
       }
       *container = add_child(parser, *container, CMARK_NODE_BLOCK_QUOTE,
-                            parser->offset + 1);
+                             parser->offset + 1);
 
     } else if (!indented && (matched = scan_atx_heading_start(
                                  input, parser->first_nonspace))) {
@@ -887,10 +882,10 @@ static void open_new_blocks(cmark_parser *parser,
     } else if (!indented && (matched = scan_open_code_fence(
                                  input, parser->first_nonspace))) {
       *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK,
-                            parser->first_nonspace + 1);
+                             parser->first_nonspace + 1);
       (*container)->as.code.fenced = true;
       (*container)->as.code.fence_char = peek_at(input, parser->first_nonspace);
-      (*container)->as.code.fence_length = matched;
+      (*container)->as.code.fence_length = (matched > 255) ? 255 : matched;
       (*container)->as.code.fence_offset =
           (int8_t)(parser->first_nonspace - parser->offset);
       (*container)->as.code.info = cmark_chunk_literal("");
@@ -904,27 +899,26 @@ static void open_new_blocks(cmark_parser *parser,
                               (matched = scan_html_block_start_7(
                                    input, parser->first_nonspace))))) {
       *container = add_child(parser, *container, CMARK_NODE_HTML_BLOCK,
-                            parser->first_nonspace + 1);
+                             parser->first_nonspace + 1);
       (*container)->as.html_block_type = matched;
       // note, we don't adjust parser->offset because the tag is part of the
       // text
     } else if (!indented && cont_type == CMARK_NODE_PARAGRAPH &&
                (lev =
                     scan_setext_heading_line(input, parser->first_nonspace))) {
-      (*container)->type = CMARK_NODE_HEADING;
+      (*container)->type = (uint16_t)CMARK_NODE_HEADING;
       (*container)->as.heading.level = lev;
       (*container)->as.heading.setext = true;
       S_advance_offset(parser, input, input->len - 1 - parser->offset, false);
     } else if (!indented &&
                !(cont_type == CMARK_NODE_PARAGRAPH && !all_matched) &&
-               (matched =
-                    scan_thematic_break(input, parser->first_nonspace))) {
+               (matched = scan_thematic_break(input, parser->first_nonspace))) {
       // it's only now that we know the line is not part of a setext heading:
       *container = add_child(parser, *container, CMARK_NODE_THEMATIC_BREAK,
-                            parser->first_nonspace + 1);
+                             parser->first_nonspace + 1);
       S_advance_offset(parser, input, input->len - 1 - parser->offset, false);
     } else if ((matched =
-                    parse_list_marker(input, parser->first_nonspace, &data)) &&
+                    parse_list_marker(parser->mem, input, parser->first_nonspace, &data)) &&
                (!indented || cont_type == CMARK_NODE_LIST)) {
       // Note that we can have new list items starting with >= 4
       // spaces indent, as long as the list container is still open.
@@ -940,16 +934,18 @@ static void open_new_blocks(cmark_parser *parser,
       save_column = parser->column;
 
       while (parser->column - save_column <= 5 &&
-		S_is_space_or_tab(peek_at(input, parser->offset))) {
+             S_is_space_or_tab(peek_at(input, parser->offset))) {
         S_advance_offset(parser, input, 1, true);
       }
 
       i = parser->column - save_column;
-      if (i >= 5 || i < 1) {
+      if (i >= 5 || i < 1 ||
+          // only spaces after list marker:
+          S_is_line_end_char(peek_at(input, parser->offset))) {
         data->padding = matched + 1;
-	parser->offset = save_offset;
-	parser->column = save_column;
-	parser->partially_consumed_tab = save_partially_consumed_tab;
+        parser->offset = save_offset;
+        parser->column = save_column;
+        parser->partially_consumed_tab = save_partially_consumed_tab;
         if (i > 0) {
           S_advance_offset(parser, input, 1, true);
         }
@@ -965,21 +961,21 @@ static void open_new_blocks(cmark_parser *parser,
       if (cont_type != CMARK_NODE_LIST ||
           !lists_match(&((*container)->as.list), data)) {
         *container = add_child(parser, *container, CMARK_NODE_LIST,
-                              parser->first_nonspace + 1);
+                               parser->first_nonspace + 1);
 
         memcpy(&((*container)->as.list), data, sizeof(*data));
       }
 
       // add the list item
       *container = add_child(parser, *container, CMARK_NODE_ITEM,
-                            parser->first_nonspace + 1);
+                             parser->first_nonspace + 1);
       /* TODO: static */
       memcpy(&((*container)->as.list), data, sizeof(*data));
       free(data);
     } else if (indented && !maybe_lazy && !parser->blank) {
       S_advance_offset(parser, input, CODE_INDENT, true);
       *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK,
-                            parser->offset + 1);
+                             parser->offset + 1);
       (*container)->as.code.fenced = false;
       (*container)->as.code.fence_char = 0;
       (*container)->as.code.fence_length = 0;
@@ -990,21 +986,19 @@ static void open_new_blocks(cmark_parser *parser,
       break;
     }
 
-    if (accepts_lines((*container)->type)) {
+    if (accepts_lines(S_type(*container))) {
       // if it's a line container, it can't contain other containers
       break;
     }
 
-    cont_type = (*container)->type;
+    cont_type = S_type(*container);
     maybe_lazy = false;
   }
 }
 
-static void add_text_to_container (cmark_parser *parser,
-                                   cmark_node *container,
-                                   cmark_node *last_matched_container,
-                                   cmark_chunk *input)
-{
+static void add_text_to_container(cmark_parser *parser, cmark_node *container,
+                                  cmark_node *last_matched_container,
+                                  cmark_chunk *input) {
   cmark_node *tmp;
   // what remains at parser->offset is a text line.  add the text to the
   // appropriate container.
@@ -1012,24 +1006,26 @@ static void add_text_to_container (cmark_parser *parser,
   S_find_first_nonspace(parser, input);
 
   if (parser->blank && container->last_child)
-    container->last_child->last_line_blank = true;
+    S_set_last_line_blank(container->last_child, true);
 
   // block quote lines are never blank as they start with >
   // and we don't count blanks in fenced code for purposes of tight/loose
   // lists or breaking out of lists.  we also don't set last_line_blank
   // on an empty list item.
-  container->last_line_blank =
-      (parser->blank && container->type != CMARK_NODE_BLOCK_QUOTE &&
-       container->type != CMARK_NODE_HEADING &&
-       container->type != CMARK_NODE_THEMATIC_BREAK &&
-       !(container->type == CMARK_NODE_CODE_BLOCK &&
-         container->as.code.fenced) &&
-       !(container->type == CMARK_NODE_ITEM && container->first_child == NULL &&
+  const cmark_node_type ctype = S_type(container);
+  const bool last_line_blank =
+      (parser->blank && ctype != CMARK_NODE_BLOCK_QUOTE &&
+       ctype != CMARK_NODE_HEADING &&
+       ctype != CMARK_NODE_THEMATIC_BREAK &&
+       !(ctype == CMARK_NODE_CODE_BLOCK && container->as.code.fenced) &&
+       !(ctype == CMARK_NODE_ITEM && container->first_child == NULL &&
          container->start_line == parser->line_number));
 
+  S_set_last_line_blank(container, last_line_blank);
+
   tmp = container;
   while (tmp->parent) {
-    tmp->parent->last_line_blank = false;
+    S_set_last_line_blank(tmp->parent, false);
     tmp = tmp->parent;
   }
 
@@ -1040,9 +1036,8 @@ static void add_text_to_container (cmark_parser *parser,
   // then treat this as a "lazy continuation line" and add it to
   // the open paragraph.
   if (parser->current != last_matched_container &&
-      container == last_matched_container &&
-      !parser->blank &&
-      parser->current->type == CMARK_NODE_PARAGRAPH) {
+      container == last_matched_container && !parser->blank &&
+      S_type(parser->current) == CMARK_NODE_PARAGRAPH) {
     add_line(parser->current, input, parser);
   } else { // not a lazy continuation
     // Finalize any blocks that were not matched and set cur to container:
@@ -1051,9 +1046,9 @@ static void add_text_to_container (cmark_parser *parser,
       assert(parser->current != NULL);
     }
 
-    if (container->type == CMARK_NODE_CODE_BLOCK) {
+    if (S_type(container) == CMARK_NODE_CODE_BLOCK) {
       add_line(container, input, parser);
-    } else if (container->type == CMARK_NODE_HTML_BLOCK) {
+    } else if (S_type(container) == CMARK_NODE_HTML_BLOCK) {
       add_line(container, input, parser);
 
       int matches_end_condition;
@@ -1094,18 +1089,20 @@ static void add_text_to_container (cmark_parser *parser,
       }
     } else if (parser->blank) {
       // ??? do nothing
-    } else if (accepts_lines(container->type)) {
-      if (container->type == CMARK_NODE_HEADING &&
+    } else if (accepts_lines(S_type(container))) {
+      if (S_type(container) == CMARK_NODE_HEADING &&
           container->as.heading.setext == false) {
         chop_trailing_hashtags(input);
       }
-      S_advance_offset(parser, input, parser->first_nonspace - parser->offset, false);
+      S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+                       false);
       add_line(container, input, parser);
     } else {
       // create paragraph container for line
       container = add_child(parser, container, CMARK_NODE_PARAGRAPH,
                             parser->first_nonspace + 1);
-      S_advance_offset(parser, input, parser->first_nonspace - parser->offset, false);
+      S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+                       false);
       add_line(container, input, parser);
     }
 
@@ -1122,21 +1119,21 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
   cmark_chunk input;
 
   if (parser->options & CMARK_OPT_VALIDATE_UTF8)
-    cmark_utf8proc_check(parser->curline, buffer, bytes);
+    cmark_utf8proc_check(&parser->curline, buffer, bytes);
   else
-    cmark_strbuf_put(parser->curline, buffer, bytes);
+    cmark_strbuf_put(&parser->curline, buffer, bytes);
 
   // ensure line ends with a newline:
-  if (bytes == 0 || !S_is_line_end_char(parser->curline->ptr[bytes - 1]))
-    cmark_strbuf_putc(parser->curline, '\n');
+  if (bytes == 0 || !S_is_line_end_char(parser->curline.ptr[bytes - 1]))
+    cmark_strbuf_putc(&parser->curline, '\n');
 
   parser->offset = 0;
   parser->column = 0;
   parser->blank = false;
   parser->partially_consumed_tab = false;
 
-  input.data = parser->curline->ptr;
-  input.len = parser->curline->size;
+  input.data = parser->curline.ptr;
+  input.len = parser->curline.size;
 
   parser->line_number++;
 
@@ -1148,7 +1145,7 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
   container = last_matched_container;
 
   // check to see if we've hit 2nd blank line, break out of list:
-  if (parser->blank && container->last_line_blank)
+  if (parser->blank && S_last_line_blank(container))
     break_out_of_lists(parser, &container);
 
   open_new_blocks(parser, &container, &input, all_matched);
@@ -1164,13 +1161,13 @@ finished:
       input.data[parser->last_line_length - 1] == '\r')
     parser->last_line_length -= 1;
 
-  cmark_strbuf_clear(parser->curline);
+  cmark_strbuf_clear(&parser->curline);
 }
 
 cmark_node *cmark_parser_finish(cmark_parser *parser) {
-  if (parser->linebuf->size) {
-    S_process_line(parser, parser->linebuf->ptr, parser->linebuf->size);
-    cmark_strbuf_clear(parser->linebuf);
+  if (parser->linebuf.size) {
+    S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size);
+    cmark_strbuf_clear(&parser->linebuf);
   }
 
   finalize_document(parser);
@@ -1179,7 +1176,7 @@ cmark_node *cmark_parser_finish(cmark_parser *parser) {
     cmark_consolidate_text_nodes(parser->root);
   }
 
-  cmark_strbuf_free(parser->curline);
+  cmark_strbuf_free(&parser->curline);
 
 #if CMARK_DEBUG_NODES
   if (cmark_node_check(parser->root, stderr)) {