commonmarker 0.9.1 → 0.9.2

data/ext/commonmarker/cmark/src/cmark_ctype.h

@@ -17,6 +17,8 @@ int cmark_isalnum(char c);
 
 int cmark_isdigit(char c);
 
+int cmark_isalpha(char c);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -2,7 +2,6 @@
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
-#include <ctype.h>
 
 #include "config.h"
 #include "cmark.h"
@@ -12,7 +11,6 @@
 #include "scanners.h"
 #include "render.h"
 
-#define safe_strlen(s) cmark_strbuf_safe_strlen(s)
 #define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
 #define LIT(s) renderer->out(renderer, s, false, LITERAL)
 #define CR() renderer->cr(renderer)
@@ -23,7 +21,7 @@
 // Functions to convert cmark_nodes to commonmark strings.
 
 static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
-                        int32_t c, unsigned char nextc) {
+                              int32_t c, unsigned char nextc) {
   bool needs_escaping = false;
   bool follows_digit =
       renderer->buffer->size > 0 &&
@@ -31,24 +29,26 @@ static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
   char encoded[ENCODED_SIZE];
 
   needs_escaping =
+      c < 0x80 &&
       escape != LITERAL &&
       ((escape == NORMAL &&
         (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' ||
          c == '>' || c == '\\' || c == '`' || c == '!' ||
-         (c == '&' && isalpha(nextc)) || (c == '!' && nextc == '[') ||
+         (c == '&' && cmark_isalpha(nextc)) || (c == '!' && nextc == '[') ||
          (renderer->begin_content && (c == '-' || c == '+' || c == '=') &&
           // begin_content doesn't get set to false til we've passed digits
           // at the beginning of line, so...
           !follows_digit) ||
          (renderer->begin_content && (c == '.' || c == ')') && follows_digit &&
           (nextc == 0 || cmark_isspace(nextc))))) ||
-       (escape == URL && (c == '`' || c == '<' || c == '>' || isspace(c) ||
-                          c == '\\' || c == ')' || c == '(')) ||
+       (escape == URL && (c == '`' || c == '<' || c == '>' ||
+                          cmark_isspace(c) || c == '\\' || c == ')' ||
+                          c == '(')) ||
        (escape == TITLE &&
         (c == '`' || c == '<' || c == '>' || c == '"' || c == '\\')));
 
   if (needs_escaping) {
-    if (isspace(c)) {
+    if (cmark_isspace(c)) {
       // use percent encoding for spaces
       snprintf(encoded, ENCODED_SIZE, "%%%2x", c);
       cmark_strbuf_puts(renderer->buffer, encoded);
@@ -66,7 +66,7 @@ static int longest_backtick_sequence(const char *code) {
   int longest = 0;
   int current = 0;
   size_t i = 0;
-  size_t code_len = safe_strlen(code);
+  size_t code_len = strlen(code);
   while (i <= code_len) {
     if (code[i] == '`') {
       current++;
@@ -85,7 +85,7 @@ static int shortest_unused_backtick_sequence(const char *code) {
   int32_t used = 1;
   int current = 0;
   size_t i = 0;
-  size_t code_len = safe_strlen(code);
+  size_t code_len = strlen(code);
   while (i <= code_len) {
     if (code[i] == '`') {
       current++;
@@ -171,7 +171,10 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
   size_t info_len, code_len;
   char listmarker[LISTMARKER_SIZE];
   char *emph_delim;
+  bool first_in_list_item;
   bufsize_t marker_width;
+  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options) &&
+                    !(CMARK_OPT_HARDBREAKS & options);
 
   // Don't adjust tight list status til we've started the list.
   // Otherwise we loose the blank line between a paragraph and
@@ -204,7 +207,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
   case CMARK_NODE_LIST:
     if (!entering && node->next && (node->next->type == CMARK_NODE_CODE_BLOCK ||
                                     node->next->type == CMARK_NODE_LIST)) {
-      // this ensures that a following code block or list will be
+      // this ensures that a following indented code block or list will be
       // inteprereted correctly.
       CR();
       LIT("<!-- end list -->");
@@ -229,7 +232,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
       snprintf(listmarker, LISTMARKER_SIZE, "%d%s%s", list_number,
                list_delim == CMARK_PAREN_DELIM ? ")" : ".",
                list_number < 10 ? "  " : " ");
-      marker_width = safe_strlen(listmarker);
+      marker_width = strlen(listmarker);
     }
     if (entering) {
       if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
@@ -256,27 +259,31 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
       }
       LIT(" ");
       renderer->begin_content = true;
-      renderer->no_wrap = true;
+      renderer->no_linebreaks = true;
     } else {
-      renderer->no_wrap = false;
+      renderer->no_linebreaks = false;
       BLANKLINE();
     }
     break;
 
   case CMARK_NODE_CODE_BLOCK:
-    BLANKLINE();
+    first_in_list_item = node->prev == NULL && node->parent &&
+          node->parent->type == CMARK_NODE_ITEM;
+
+    if (!first_in_list_item) {
+      BLANKLINE();
+    }
     info = cmark_node_get_fence_info(node);
-    info_len = safe_strlen(info);
+    info_len = strlen(info);
     code = cmark_node_get_literal(node);
-    code_len = safe_strlen(code);
+    code_len = strlen(code);
     // use indented form if no info, and code doesn't
     // begin or end with a blank line, and code isn't
     // first thing in a list item
-    if (info_len == 0 &&
-        (code_len > 2 && !isspace((unsigned char)code[0]) &&
-         !(isspace((unsigned char)code[code_len - 1]) && isspace((unsigned char)code[code_len - 2]))) &&
-        !(node->prev == NULL && node->parent &&
-          node->parent->type == CMARK_NODE_ITEM)) {
+    if (info_len == 0 && (code_len > 2 && !cmark_isspace(code[0]) &&
+                          !(cmark_isspace(code[code_len - 1]) &&
+                            cmark_isspace(code[code_len - 2]))) &&
+        !first_in_list_item) {
       LIT("    ");
       cmark_strbuf_puts(renderer->prefix, "    ");
       OUT(cmark_node_get_literal(node), false, LITERAL);
@@ -327,7 +334,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     break;
 
   case CMARK_NODE_TEXT:
-    OUT(cmark_node_get_literal(node), true, NORMAL);
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
     break;
 
   case CMARK_NODE_LINEBREAK:
@@ -338,16 +345,22 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     break;
 
   case CMARK_NODE_SOFTBREAK:
-    if (renderer->width == 0 && !(CMARK_OPT_HARDBREAKS & options)) {
+    if (CMARK_OPT_HARDBREAKS & options) {
+      LIT("  ");
+      CR();
+    } else if (!renderer->no_linebreaks &&
+		renderer->width == 0 &&
+		!(CMARK_OPT_HARDBREAKS & options) &&
+                !(CMARK_OPT_NOBREAKS & options)) {
       CR();
     } else {
-      OUT(" ", true, LITERAL);
+      OUT(" ", allow_wrap, LITERAL);
     }
     break;
 
   case CMARK_NODE_CODE:
     code = cmark_node_get_literal(node);
-    code_len = safe_strlen(code);
+    code_len = strlen(code);
     numticks = shortest_unused_backtick_sequence(code);
     for (i = 0; i < numticks; i++) {
       LIT("`");
@@ -355,7 +368,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     if (code_len == 0 || code[0] == '`') {
       LIT(" ");
     }
-    OUT(cmark_node_get_literal(node), true, LITERAL);
+    OUT(cmark_node_get_literal(node), allow_wrap, LITERAL);
     if (code_len == 0 || code[code_len - 1] == '`') {
       LIT(" ");
     }
@@ -417,7 +430,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
         LIT("](");
         OUT(cmark_node_get_url(node), false, URL);
         title = cmark_node_get_title(node);
-        if (safe_strlen(title) > 0) {
+        if (strlen(title) > 0) {
           LIT(" \"");
           OUT(title, false, TITLE);
           LIT("\"");
@@ -434,8 +447,8 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
       LIT("](");
       OUT(cmark_node_get_url(node), false, URL);
       title = cmark_node_get_title(node);
-      if (safe_strlen(title) > 0) {
-        OUT(" \"", true, LITERAL);
+      if (strlen(title) > 0) {
+        OUT(" \"", allow_wrap, LITERAL);
         OUT(title, false, TITLE);
         LIT("\"");
       }

data/ext/commonmarker/cmark/src/config.h.in

@@ -69,6 +69,14 @@ CMARK_INLINE int c99_snprintf(char *outBuf, size_t size, const char *format, ...
 
 #endif
 
+#ifdef _WIN32
+# include <BaseTsd.h>
+  typedef SSIZE_T ssize_t;
+  typedef SIZE_T size_t;
+#else
+# include <sys/types.h>
+#endif
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -228,6 +228,8 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type,
   case CMARK_NODE_SOFTBREAK:
     if (options & CMARK_OPT_HARDBREAKS) {
       cmark_strbuf_puts(html, "<br />\n");
+    } else if (options & CMARK_OPT_NOBREAKS) {
+      cmark_strbuf_putc(html, ' ');
     } else {
       cmark_strbuf_putc(html, '\n');
     }
@@ -322,7 +324,7 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type,
 
 char *cmark_render_html(cmark_node *root, int options) {
   char *result;
-  cmark_strbuf html = GH_BUF_INIT;
+  cmark_strbuf html = CMARK_BUF_INIT(cmark_node_mem(root));
   cmark_event_type ev_type;
   cmark_node *cur;
   struct render_state state = {&html, NULL};

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

@@ -22,13 +22,13 @@ static const char *LEFTSINGLEQUOTE = "\xE2\x80\x98";
 static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99";
 
 // Macros for creating various kinds of simple.
-#define make_str(s) make_literal(CMARK_NODE_TEXT, s)
-#define make_code(s) make_literal(CMARK_NODE_CODE, s)
-#define make_raw_html(s) make_literal(CMARK_NODE_HTML_INLINE, s)
-#define make_linebreak() make_simple(CMARK_NODE_LINEBREAK)
-#define make_softbreak() make_simple(CMARK_NODE_SOFTBREAK)
-#define make_emph() make_simple(CMARK_NODE_EMPH)
-#define make_strong() make_simple(CMARK_NODE_STRONG)
+#define make_str(mem, s) make_literal(mem, CMARK_NODE_TEXT, s)
+#define make_code(mem, s) make_literal(mem, CMARK_NODE_CODE, s)
+#define make_raw_html(mem, s) make_literal(mem, CMARK_NODE_HTML_INLINE, s)
+#define make_linebreak(mem) make_simple(mem, CMARK_NODE_LINEBREAK)
+#define make_softbreak(mem) make_simple(mem, CMARK_NODE_SOFTBREAK)
+#define make_emph(mem) make_simple(mem, CMARK_NODE_EMPH)
+#define make_strong(mem) make_simple(mem, CMARK_NODE_STRONG)
 
 typedef struct delimiter {
   struct delimiter *previous;
@@ -42,6 +42,7 @@ typedef struct delimiter {
 } delimiter;
 
 typedef struct {
+  cmark_mem *mem;
   cmark_chunk input;
   bufsize_t pos;
   cmark_reference_map *refmap;
@@ -57,66 +58,46 @@ static delimiter *S_insert_emph(subject *subj, delimiter *opener,
 
 static int parse_inline(subject *subj, cmark_node *parent, int options);
 
-static void subject_from_buf(subject *e, cmark_strbuf *buffer,
+static void subject_from_buf(cmark_mem *mem, subject *e, cmark_strbuf *buffer,
                              cmark_reference_map *refmap);
 static bufsize_t subject_find_special_char(subject *subj, int options);
 
 // Create an inline with a literal string value.
-static CMARK_INLINE cmark_node *make_literal(cmark_node_type t, cmark_chunk s) {
-  cmark_node *e = (cmark_node *)calloc(1, sizeof(*e));
-  if (e != NULL) {
-    e->type = t;
-    e->as.literal = s;
-    e->next = NULL;
-    e->prev = NULL;
-    e->parent = NULL;
-    e->first_child = NULL;
-    e->last_child = NULL;
-    // These fields aren't used for inlines:
-    e->start_line = 0;
-    e->start_column = 0;
-    e->end_line = 0;
-  }
+static CMARK_INLINE cmark_node *make_literal(cmark_mem *mem, cmark_node_type t, cmark_chunk s) {
+  cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e));
+  cmark_strbuf_init(mem, &e->content, 0);
+  e->type = t;
+  e->as.literal = s;
   return e;
 }
 
 // Create an inline with no value.
-static CMARK_INLINE cmark_node *make_simple(cmark_node_type t) {
-  cmark_node *e = (cmark_node *)calloc(1, sizeof(*e));
-  if (e != NULL) {
-    e->type = t;
-    e->next = NULL;
-    e->prev = NULL;
-    e->parent = NULL;
-    e->first_child = NULL;
-    e->last_child = NULL;
-    // These fields aren't used for inlines:
-    e->start_line = 0;
-    e->start_column = 0;
-    e->end_line = 0;
-  }
+static CMARK_INLINE cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) {
+  cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e));
+  cmark_strbuf_init(mem, &e->content, 0);
+  e->type = t;
   return e;
 }
 
 // Like make_str, but parses entities.
-static cmark_node *make_str_with_entities(cmark_chunk *content) {
-  cmark_strbuf unescaped = GH_BUF_INIT;
+static cmark_node *make_str_with_entities(cmark_mem *mem, cmark_chunk *content) {
+  cmark_strbuf unescaped = CMARK_BUF_INIT(mem);
 
   if (houdini_unescape_html(&unescaped, content->data, content->len)) {
-    return make_str(cmark_chunk_buf_detach(&unescaped));
+    return make_str(mem, cmark_chunk_buf_detach(&unescaped));
   } else {
-    return make_str(*content);
+    return make_str(mem, *content);
   }
 }
 
 // Duplicate a chunk by creating a copy of the buffer not by reusing the
 // buffer like cmark_chunk_dup does.
-static cmark_chunk chunk_clone(cmark_chunk *src) {
+static cmark_chunk chunk_clone(cmark_mem *mem, cmark_chunk *src) {
   cmark_chunk c;
   bufsize_t len = src->len;
 
   c.len = len;
-  c.data = (unsigned char *)malloc(len + 1);
+  c.data = (unsigned char *)mem->calloc(len + 1, 1);
   c.alloc = 1;
   memcpy(c.data, src->data, len);
   c.data[len] = '\0';
@@ -124,8 +105,8 @@ static cmark_chunk chunk_clone(cmark_chunk *src) {
   return c;
 }
 
-static cmark_chunk cmark_clean_autolink(cmark_chunk *url, int is_email) {
-  cmark_strbuf buf = GH_BUF_INIT;
+static cmark_chunk cmark_clean_autolink(cmark_mem *mem, cmark_chunk *url, int is_email) {
+  cmark_strbuf buf = CMARK_BUF_INIT(mem);
 
   cmark_chunk_trim(url);
 
@@ -141,16 +122,17 @@ static cmark_chunk cmark_clean_autolink(cmark_chunk *url, int is_email) {
   return cmark_chunk_buf_detach(&buf);
 }
 
-static CMARK_INLINE cmark_node *make_autolink(cmark_chunk url, int is_email) {
-  cmark_node *link = make_simple(CMARK_NODE_LINK);
-  link->as.link.url = cmark_clean_autolink(&url, is_email);
+static CMARK_INLINE cmark_node *make_autolink(cmark_mem *mem, cmark_chunk url, int is_email) {
+  cmark_node *link = make_simple(mem, CMARK_NODE_LINK);
+  link->as.link.url = cmark_clean_autolink(mem, &url, is_email);
   link->as.link.title = cmark_chunk_literal("");
-  cmark_node_append_child(link, make_str_with_entities(&url));
+  cmark_node_append_child(link, make_str_with_entities(mem, &url));
   return link;
 }
 
-static void subject_from_buf(subject *e, cmark_strbuf *buffer,
+static void subject_from_buf(cmark_mem *mem, subject *e, cmark_strbuf *buffer,
                              cmark_reference_map *refmap) {
+  e->mem = mem;
   e->input.data = buffer->ptr;
   e->input.len = buffer->size;
   e->input.alloc = 0;
@@ -251,16 +233,16 @@ static cmark_node *handle_backticks(subject *subj) {
 
   if (endpos == 0) {      // not found
     subj->pos = startpos; // rewind
-    return make_str(openticks);
+    return make_str(subj->mem, openticks);
   } else {
-    cmark_strbuf buf = GH_BUF_INIT;
+    cmark_strbuf buf = CMARK_BUF_INIT(subj->mem);
 
     cmark_strbuf_set(&buf, subj->input.data + startpos,
                      endpos - startpos - openticks.len);
     cmark_strbuf_trim(&buf);
     cmark_strbuf_normalize_whitespace(&buf);
 
-    return make_code(cmark_chunk_buf_detach(&buf));
+    return make_code(subj->mem, cmark_chunk_buf_detach(&buf));
   }
 }
 
@@ -362,10 +344,7 @@ static void remove_delimiter(subject *subj, delimiter *delim) {
 
 static void push_delimiter(subject *subj, unsigned char c, bool can_open,
                            bool can_close, cmark_node *inl_text) {
-  delimiter *delim = (delimiter *)malloc(sizeof(delimiter));
-  if (delim == NULL) {
-    return;
-  }
+  delimiter *delim = (delimiter *)subj->mem->calloc(1, sizeof(delimiter));
   delim->delim_char = c;
   delim->can_open = can_open;
   delim->can_close = can_close;
@@ -398,7 +377,7 @@ static cmark_node *handle_delim(subject *subj, unsigned char c, bool smart) {
     contents = cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims);
   }
 
-  inl_text = make_str(contents);
+  inl_text = make_str(subj->mem, contents);
 
   if ((can_open || can_close) && (!(c == '\'' || c == '"') || smart)) {
     push_delimiter(subj, c, can_open, can_close, inl_text);
@@ -414,7 +393,7 @@ static cmark_node *handle_hyphen(subject *subj, bool smart) {
   advance(subj);
 
   if (!smart || peek_char(subj) != '-') {
-    return make_str(cmark_chunk_literal("-"));
+    return make_str(subj->mem, cmark_chunk_literal("-"));
   }
 
   while (smart && peek_char(subj) == '-') {
@@ -425,7 +404,7 @@ static cmark_node *handle_hyphen(subject *subj, bool smart) {
   int en_count = 0;
   int em_count = 0;
   int i;
-  cmark_strbuf buf = GH_BUF_INIT;
+  cmark_strbuf buf = CMARK_BUF_INIT(subj->mem);
 
   if (numhyphens % 3 == 0) { // if divisible by 3, use all em dashes
     em_count = numhyphens / 3;
@@ -447,7 +426,7 @@ static cmark_node *handle_hyphen(subject *subj, bool smart) {
     cmark_strbuf_puts(&buf, ENDASH);
   }
 
-  return make_str(cmark_chunk_buf_detach(&buf));
+  return make_str(subj->mem, cmark_chunk_buf_detach(&buf));
 }
 
 // Assumes we have a period at the current position.
@@ -457,12 +436,12 @@ static cmark_node *handle_period(subject *subj, bool smart) {
     advance(subj);
     if (peek_char(subj) == '.') {
       advance(subj);
-      return make_str(cmark_chunk_literal(ELLIPSES));
+      return make_str(subj->mem, cmark_chunk_literal(ELLIPSES));
     } else {
-      return make_str(cmark_chunk_literal(".."));
+      return make_str(subj->mem, cmark_chunk_literal(".."));
     }
   } else {
-    return make_str(cmark_chunk_literal("."));
+    return make_str(subj->mem, cmark_chunk_literal("."));
   }
 }
 
@@ -508,18 +487,18 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) {
           closer = closer->next;
         }
       } else if (closer->delim_char == '\'') {
-        cmark_chunk_free(&closer->inl_text->as.literal);
+        cmark_chunk_free(subj->mem, &closer->inl_text->as.literal);
         closer->inl_text->as.literal = cmark_chunk_literal(RIGHTSINGLEQUOTE);
         if (opener_found) {
-          cmark_chunk_free(&opener->inl_text->as.literal);
+          cmark_chunk_free(subj->mem, &opener->inl_text->as.literal);
           opener->inl_text->as.literal = cmark_chunk_literal(LEFTSINGLEQUOTE);
         }
         closer = closer->next;
       } else if (closer->delim_char == '"') {
-        cmark_chunk_free(&closer->inl_text->as.literal);
+        cmark_chunk_free(subj->mem, &closer->inl_text->as.literal);
         closer->inl_text->as.literal = cmark_chunk_literal(RIGHTDOUBLEQUOTE);
         if (opener_found) {
-          cmark_chunk_free(&opener->inl_text->as.literal);
+          cmark_chunk_free(subj->mem, &opener->inl_text->as.literal);
           opener->inl_text->as.literal = cmark_chunk_literal(LEFTDOUBLEQUOTE);
         }
         closer = closer->next;
@@ -552,7 +531,7 @@ static delimiter *S_insert_emph(subject *subj, delimiter *opener,
   cmark_node *closer_inl = closer->inl_text;
   bufsize_t opener_num_chars = opener_inl->as.literal.len;
   bufsize_t closer_num_chars = closer_inl->as.literal.len;
-  cmark_node *tmp, *emph, *first_child, *last_child;
+  cmark_node *tmp, *tmpnext, *emph;
 
   // calculate the actual number of characters used from this closer
   if (closer_num_chars < 3 || opener_num_chars < 3) {
@@ -576,37 +555,22 @@ static delimiter *S_insert_emph(subject *subj, delimiter *opener,
     delim = tmp_delim;
   }
 
-  first_child = opener_inl->next;
-  last_child = closer_inl->prev;
+  // create new emph or strong, and splice it in to our inlines
+  // between the opener and closer
+  emph = use_delims == 1 ? make_emph(subj->mem) : make_strong(subj->mem);
+
+  tmp = opener_inl->next;
+  while (tmp && tmp != closer_inl) {
+    tmpnext = tmp->next;
+    cmark_node_append_child(emph, tmp);
+    tmp = tmpnext;
+  }
+  cmark_node_insert_after(opener_inl, emph);
 
   // if opener has 0 characters, remove it and its associated inline
   if (opener_num_chars == 0) {
-    // replace empty opener inline with emph
-    cmark_chunk_free(&(opener_inl->as.literal));
-    emph = opener_inl;
-    emph->type = use_delims == 1 ? CMARK_NODE_EMPH : CMARK_NODE_STRONG;
-    // remove opener from list
+    cmark_node_free(opener_inl);
     remove_delimiter(subj, opener);
-  } else {
-    // create new emph or strong, and splice it in to our inlines
-    // between the opener and closer
-    emph = use_delims == 1 ? make_emph() : make_strong();
-    emph->parent = opener_inl->parent;
-    emph->prev = opener_inl;
-    opener_inl->next = emph;
-  }
-
-  // push children below emph
-  emph->next = closer_inl;
-  closer_inl->prev = emph;
-  emph->first_child = first_child;
-  emph->last_child = last_child;
-
-  // fix children pointers
-  first_child->prev = NULL;
-  last_child->next = NULL;
-  for (tmp = first_child; tmp != NULL; tmp = tmp->next) {
-    tmp->parent = emph;
   }
 
   // if closer has 0 characters, remove it and its associated inline
@@ -629,18 +593,18 @@ static cmark_node *handle_backslash(subject *subj) {
   if (cmark_ispunct(
           nextchar)) { // only ascii symbols and newline can be escaped
     advance(subj);
-    return make_str(cmark_chunk_dup(&subj->input, subj->pos - 1, 1));
+    return make_str(subj->mem, cmark_chunk_dup(&subj->input, subj->pos - 1, 1));
   } else if (!is_eof(subj) && skip_line_end(subj)) {
-    return make_linebreak();
+    return make_linebreak(subj->mem);
   } else {
-    return make_str(cmark_chunk_literal("\\"));
+    return make_str(subj->mem, cmark_chunk_literal("\\"));
   }
 }
 
 // Parse an entity or a regular "&" string.
 // Assumes the subject has an '&' character at the current position.
 static cmark_node *handle_entity(subject *subj) {
-  cmark_strbuf ent = GH_BUF_INIT;
+  cmark_strbuf ent = CMARK_BUF_INIT(subj->mem);
   bufsize_t len;
 
   advance(subj);
@@ -649,16 +613,16 @@ static cmark_node *handle_entity(subject *subj) {
                              subj->input.len - subj->pos);
 
   if (len == 0)
-    return make_str(cmark_chunk_literal("&"));
+    return make_str(subj->mem, cmark_chunk_literal("&"));
 
   subj->pos += len;
-  return make_str(cmark_chunk_buf_detach(&ent));
+  return make_str(subj->mem, cmark_chunk_buf_detach(&ent));
 }
 
 // Clean a URL: remove surrounding whitespace and surrounding <>,
 // and remove \ that escape punctuation.
-cmark_chunk cmark_clean_url(cmark_chunk *url) {
-  cmark_strbuf buf = GH_BUF_INIT;
+cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url) {
+  cmark_strbuf buf = CMARK_BUF_INIT(mem);
 
   cmark_chunk_trim(url);
 
@@ -677,8 +641,8 @@ cmark_chunk cmark_clean_url(cmark_chunk *url) {
   return cmark_chunk_buf_detach(&buf);
 }
 
-cmark_chunk cmark_clean_title(cmark_chunk *title) {
-  cmark_strbuf buf = GH_BUF_INIT;
+cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title) {
+  cmark_strbuf buf = CMARK_BUF_INIT(mem);
   unsigned char first, last;
 
   if (title->len == 0) {
@@ -715,7 +679,7 @@ static cmark_node *handle_pointy_brace(subject *subj) {
     contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1);
     subj->pos += matchlen;
 
-    return make_autolink(contents, 0);
+    return make_autolink(subj->mem, contents, 0);
   }
 
   // next try to match an email autolink
@@ -724,7 +688,7 @@ static cmark_node *handle_pointy_brace(subject *subj) {
     contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1);
     subj->pos += matchlen;
 
-    return make_autolink(contents, 1);
+    return make_autolink(subj->mem, contents, 1);
   }
 
   // finally, try to match an html tag
@@ -732,11 +696,11 @@ static cmark_node *handle_pointy_brace(subject *subj) {
   if (matchlen > 0) {
     contents = cmark_chunk_dup(&subj->input, subj->pos - 1, matchlen + 1);
     subj->pos += matchlen;
-    return make_raw_html(contents);
+    return make_raw_html(subj->mem, contents);
   }
 
   // if nothing matches, just return the opening <:
-  return make_str(cmark_chunk_literal("<"));
+  return make_str(subj->mem, cmark_chunk_literal("<"));
 }
 
 // Parse a link label.  Returns 1 if successful.
@@ -786,7 +750,7 @@ noMatch:
 }
 
 // Return a link, an image, or a literal close bracket.
-static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) {
+static cmark_node *handle_close_bracket(subject *subj) {
   bufsize_t initial_pos;
   bufsize_t starturl, endurl, starttitle, endtitle, endall;
   bufsize_t n;
@@ -796,10 +760,10 @@ static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) {
   cmark_chunk url_chunk, title_chunk;
   cmark_chunk url, title;
   delimiter *opener;
-  cmark_node *link_text;
   cmark_node *inl;
   cmark_chunk raw_label;
   int found_label;
+  cmark_node *tmp, *tmpnext;
 
   advance(subj); // advance past ]
   initial_pos = subj->pos;
@@ -814,18 +778,17 @@ static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) {
   }
 
   if (opener == NULL) {
-    return make_str(cmark_chunk_literal("]"));
+    return make_str(subj->mem, cmark_chunk_literal("]"));
   }
 
   if (!opener->active) {
     // take delimiter off stack
     remove_delimiter(subj, opener);
-    return make_str(cmark_chunk_literal("]"));
+    return make_str(subj->mem, cmark_chunk_literal("]"));
   }
 
   // If we got here, we matched a potential link/image text.
   is_image = opener->delim_char == '!';
-  link_text = opener->inl_text->next;
 
   // Now we check to see if it's a link/image.
 
@@ -852,10 +815,10 @@ static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) {
       url_chunk = cmark_chunk_dup(&subj->input, starturl, endurl - starturl);
       title_chunk =
           cmark_chunk_dup(&subj->input, starttitle, endtitle - starttitle);
-      url = cmark_clean_url(&url_chunk);
-      title = cmark_clean_title(&title_chunk);
-      cmark_chunk_free(&url_chunk);
-      cmark_chunk_free(&title_chunk);
+      url = cmark_clean_url(subj->mem, &url_chunk);
+      title = cmark_clean_title(subj->mem, &title_chunk);
+      cmark_chunk_free(subj->mem, &url_chunk);
+      cmark_chunk_free(subj->mem, &title_chunk);
       goto match;
 
     } else {
@@ -868,7 +831,7 @@ static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) {
   raw_label = cmark_chunk_literal("");
   found_label = link_label(subj, &raw_label);
   if (!found_label || raw_label.len == 0) {
-    cmark_chunk_free(&raw_label);
+    cmark_chunk_free(subj->mem, &raw_label);
     raw_label = cmark_chunk_dup(&subj->input, opener->position,
                                 initial_pos - opener->position - 1);
   }
@@ -880,11 +843,11 @@ static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) {
   }
 
   ref = cmark_reference_lookup(subj->refmap, &raw_label);
-  cmark_chunk_free(&raw_label);
+  cmark_chunk_free(subj->mem, &raw_label);
 
   if (ref != NULL) { // found
-    url = chunk_clone(&ref->url);
-    title = chunk_clone(&ref->title);
+    url = chunk_clone(subj->mem, &ref->url);
+    title = chunk_clone(subj->mem, &ref->title);
     goto match;
   } else {
     goto noMatch;
@@ -894,27 +857,25 @@ noMatch:
   // If we fall through to here, it means we didn't match a link:
   remove_delimiter(subj, opener); // remove this opener from delimiter list
   subj->pos = initial_pos;
-  return make_str(cmark_chunk_literal("]"));
+  return make_str(subj->mem, cmark_chunk_literal("]"));
 
 match:
-  inl = opener->inl_text;
-  inl->type = is_image ? CMARK_NODE_IMAGE : CMARK_NODE_LINK;
-  cmark_chunk_free(&inl->as.literal);
-  inl->first_child = link_text;
-  process_emphasis(subj, opener);
+  inl = make_simple(subj->mem, is_image ? CMARK_NODE_IMAGE : CMARK_NODE_LINK);
   inl->as.link.url = url;
   inl->as.link.title = title;
-  inl->next = NULL;
-  if (link_text) {
-    cmark_node *tmp;
-    link_text->prev = NULL;
-    for (tmp = link_text; tmp->next != NULL; tmp = tmp->next) {
-      tmp->parent = inl;
-    }
-    tmp->parent = inl;
-    inl->last_child = tmp;
+  cmark_node_insert_before(opener->inl_text, inl);
+  // Add link text:
+  tmp = opener->inl_text->next;
+  while (tmp) {
+    tmpnext = tmp->next;
+    cmark_node_append_child(inl, tmp);
+    tmp = tmpnext;
   }
-  parent->last_child = inl;
+
+  // Free the bracket [:
+  cmark_node_free(opener->inl_text);
+
+  process_emphasis(subj, opener);
 
   // Now, if we have a link, we also want to deactivate earlier link
   // delimiters. (This code can be removed if we decide to allow links
@@ -952,9 +913,9 @@ static cmark_node *handle_newline(subject *subj) {
   skip_spaces(subj);
   if (nlpos > 1 && peek_at(subj, nlpos - 1) == ' ' &&
       peek_at(subj, nlpos - 2) == ' ') {
-    return make_linebreak();
+    return make_linebreak(subj->mem);
   } else {
-    return make_softbreak();
+    return make_softbreak(subj->mem);
   }
 }
 
@@ -1043,20 +1004,20 @@ static int parse_inline(subject *subj, cmark_node *parent, int options) {
     break;
   case '[':
     advance(subj);
-    new_inl = make_str(cmark_chunk_literal("["));
+    new_inl = make_str(subj->mem, cmark_chunk_literal("["));
     push_delimiter(subj, '[', true, false, new_inl);
     break;
   case ']':
-    new_inl = handle_close_bracket(subj, parent);
+    new_inl = handle_close_bracket(subj);
     break;
   case '!':
     advance(subj);
     if (peek_char(subj) == '[') {
       advance(subj);
-      new_inl = make_str(cmark_chunk_literal("!["));
+      new_inl = make_str(subj->mem, cmark_chunk_literal("!["));
       push_delimiter(subj, '!', false, true, new_inl);
     } else {
-      new_inl = make_str(cmark_chunk_literal("!"));
+      new_inl = make_str(subj->mem, cmark_chunk_literal("!"));
     }
     break;
   default:
@@ -1069,7 +1030,7 @@ static int parse_inline(subject *subj, cmark_node *parent, int options) {
       cmark_chunk_rtrim(&contents);
     }
 
-    new_inl = make_str(contents);
+    new_inl = make_str(subj->mem, contents);
   }
   if (new_inl != NULL) {
     cmark_node_append_child(parent, new_inl);
@@ -1079,10 +1040,10 @@ static int parse_inline(subject *subj, cmark_node *parent, int options) {
 }
 
 // Parse inlines from parent's string_content, adding as children of parent.
-extern void cmark_parse_inlines(cmark_node *parent, cmark_reference_map *refmap,
+extern void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent, cmark_reference_map *refmap,
                                 int options) {
   subject subj;
-  subject_from_buf(&subj, &parent->string_content, refmap);
+  subject_from_buf(mem, &subj, &parent->content, refmap);
   cmark_chunk_rtrim(&subj.input);
 
   while (!is_eof(&subj) && parse_inline(&subj, parent, options))
@@ -1103,7 +1064,7 @@ static void spnl(subject *subj) {
 // Modify refmap if a reference is encountered.
 // Return 0 if no reference found, otherwise position of subject
 // after reference is parsed.
-bufsize_t cmark_parse_reference_inline(cmark_strbuf *input,
+bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_strbuf *input,
                                        cmark_reference_map *refmap) {
   subject subj;
 
@@ -1114,7 +1075,7 @@ bufsize_t cmark_parse_reference_inline(cmark_strbuf *input,
   bufsize_t matchlen = 0;
   bufsize_t beforetitle;
 
-  subject_from_buf(&subj, input, NULL);
+  subject_from_buf(mem, &subj, input, NULL);
 
   // parse label:
   if (!link_label(&subj, &lab) || lab.len == 0)