commonmarker 0.14.14 → 0.15.0

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

@@ -24,12 +24,11 @@ typedef struct {
 
 typedef struct {
   bool is_header;
-  unsigned char *raw_content;
-  size_t raw_content_len;
 } node_table_row;
 
 static void free_table_cell(cmark_mem *mem, void *data) {
-  cmark_node_free((cmark_node *)data);
+  cmark_strbuf_free((cmark_strbuf *)data);
+  mem->free(data);
 }
 
 static void free_table_row(cmark_mem *mem, table_row *row) {
@@ -48,9 +47,7 @@ static void free_node_table(cmark_mem *mem, void *ptr) {
 }
 
 static void free_node_table_row(cmark_mem *mem, void *ptr) {
-  node_table_row *ntr = (node_table_row *)ptr;
-  mem->free(ntr->raw_content);
-  mem->free(ntr);
+  mem->free(ptr);
 }
 
 static int get_n_table_columns(cmark_node *node) {
@@ -83,159 +80,64 @@ static int set_table_alignments(cmark_node *node, uint8_t *alignments) {
   return 1;
 }
 
-static void maybe_consume_pipe(cmark_node **n, int *offset) {
-  if (*n && (*n)->type == CMARK_NODE_TEXT && *offset < (*n)->as.literal.len &&
-      (*n)->as.literal.data[*offset] == '|')
-    ++*offset;
-}
-
-static int find_unescaped_pipe(const cmark_chunk *chunk, int offset) {
-  bool escaping = false;
-  for (; offset < chunk->len; ++offset) {
-    if (escaping)
-      escaping = false;
-    else if (chunk->data[offset] == '\\')
-      escaping = true;
-    else if (chunk->data[offset] == '|')
-      return offset;
-  }
-  return -1;
-}
-
-static cmark_node *consume_until_pipe_or_eol(cmark_syntax_extension *self,
-                                             cmark_parser *parser,
-                                             cmark_node **n, int *offset) {
-  cmark_node *result =
-      cmark_node_new_with_mem(CMARK_NODE_TABLE_CELL, parser->mem);
-  cmark_node_set_syntax_extension(result, self);
-  bool was_escape = false;
-
-  while (*n) {
-    cmark_node *node = *n;
-
-    if (node->type == CMARK_NODE_TEXT) {
-      cmark_node *child = cmark_parser_add_child(
-          parser, result, CMARK_NODE_TEXT, cmark_parser_get_offset(parser));
-
-      if (was_escape) {
-        child->as.literal = cmark_chunk_dup(&node->as.literal, *offset, 1);
-        cmark_node_own(child);
-        if (child->as.literal.data[0] == '|')
-          cmark_node_free(child->prev);
-        ++*offset;
-        if (*offset >= node->as.literal.len) {
-          *offset = 0;
-          *n = node->next;
-        }
-        was_escape = false;
-        continue;
-      }
-
-      const char *lit = (char *)node->as.literal.data + *offset;
-      const int lit_len = node->as.literal.len - *offset;
-
-      if (lit_len == 1 && lit[0] == '\\' &&
-          node->next &&
-          node->next->type == CMARK_NODE_TEXT) {
-        child->as.literal = cmark_chunk_dup(&node->as.literal, *offset, 1);
-        cmark_node_own(child);
-        was_escape = true;
-        *n = node->next;
-        continue;
-      }
-
-      int pipe = find_unescaped_pipe(&node->as.literal, *offset);
-      if (pipe == -1) {
-        child->as.literal = cmark_chunk_dup(&node->as.literal, *offset,
-                                            node->as.literal.len - *offset);
-        cmark_node_own(child);
-      } else {
-        pipe -= *offset;
-
-        child->as.literal = cmark_chunk_dup(&node->as.literal, *offset, pipe);
-        cmark_node_own(child);
-
-        *offset += pipe + 1;
-        if (*offset >= node->as.literal.len) {
-          *offset = 0;
-          *n = node->next;
-        }
-        break;
-      }
-
-      *n = node->next;
-      *offset = 0;
-    } else {
-      cmark_node *next = node->next;
-      cmark_node_append_child(result, node);
-      cmark_node_own(node);
-      *n = next;
-      *offset = 0;
-    }
-  }
+static cmark_strbuf *unescape_pipes(cmark_mem *mem, unsigned char *string, bufsize_t len)
+{
+  cmark_strbuf *res = (cmark_strbuf *)mem->calloc(1, sizeof(cmark_strbuf));
+  bufsize_t r, w;
 
-  if (!result->first_child) {
-    cmark_node_free(result);
-    return NULL;
-  }
+  cmark_strbuf_init(mem, res, len + 1);
+  cmark_strbuf_put(res, string, len);
+  cmark_strbuf_putc(res, '\0');
 
-  cmark_consolidate_text_nodes(result);
+  for (r = 0, w = 0; r < len; ++r) {
+    if (res->ptr[r] == '\\' && res->ptr[r + 1] == '|')
+      r++;
 
-  if (result->first_child->type == CMARK_NODE_TEXT) {
-    cmark_chunk c = cmark_chunk_ltrim_new(parser->mem, &result->first_child->as.literal);
-    cmark_chunk_free(parser->mem, &result->first_child->as.literal);
-    result->first_child->as.literal = c;
+    res->ptr[w++] = res->ptr[r];
   }
 
-  if (result->last_child->type == CMARK_NODE_TEXT) {
-    cmark_chunk c = cmark_chunk_rtrim_new(parser->mem, &result->last_child->as.literal);
-    cmark_chunk_free(parser->mem, &result->last_child->as.literal);
-    result->last_child->as.literal = c;
-  }
+  cmark_strbuf_truncate(res, w);
 
-  return result;
-}
-
-static int table_ispunct(char c) {
-  return cmark_ispunct(c) && c != '|';
+  return res;
 }
 
 static table_row *row_from_string(cmark_syntax_extension *self,
                                   cmark_parser *parser, unsigned char *string,
                                   int len) {
   table_row *row = NULL;
-
-  cmark_node *temp_container =
-      cmark_node_new_with_mem(CMARK_NODE_PARAGRAPH, parser->mem);
-  cmark_strbuf_set(&temp_container->content, string, len);
-
-  cmark_manage_extensions_special_characters(parser, true);
-  cmark_parser_set_backslash_ispunct_func(parser, table_ispunct);
-  cmark_parse_inlines(parser, temp_container, parser->refmap, parser->options);
-  cmark_parser_set_backslash_ispunct_func(parser, NULL);
-  cmark_manage_extensions_special_characters(parser, false);
-
-  if (!temp_container->first_child) {
-    cmark_node_free(temp_container);
-    return NULL;
-  }
+  bufsize_t cell_matched, pipe_matched, offset = 0;
 
   row = (table_row *)parser->mem->calloc(1, sizeof(table_row));
   row->n_columns = 0;
   row->cells = NULL;
 
-  cmark_node *node = temp_container->first_child;
-  int offset = 0;
+  if (len > 0 && string[0] == '|')
+    ++offset;
 
-  maybe_consume_pipe(&node, &offset);
-  cmark_node *child;
-  while ((child = consume_until_pipe_or_eol(self, parser, &node, &offset)) !=
-         NULL) {
-    ++row->n_columns;
-    row->cells = cmark_llist_append(parser->mem, row->cells, child);
-  }
+  do {
+    cell_matched = scan_table_cell(string, len, offset);
+    pipe_matched = scan_table_cell_end(string, len, offset + cell_matched);
+
+    if (cell_matched || pipe_matched) {
+      cmark_strbuf *cell_buf = unescape_pipes(parser->mem, string + offset,
+          cell_matched);
+      cmark_strbuf_trim(cell_buf);
+      row->n_columns += 1;
+      row->cells = cmark_llist_append(parser->mem, row->cells, cell_buf);
+    }
 
-  cmark_node_free(temp_container);
+    offset += cell_matched + pipe_matched;
+
+    if (!pipe_matched) {
+      pipe_matched = scan_table_row_end(string, len, offset);
+      offset += pipe_matched;
+    }
+  } while ((cell_matched || pipe_matched) && offset < len);
+
+  if (offset != len || !row->n_columns) {
+    free_table_row(parser->mem, row);
+    row = NULL;
+  }
 
   return row;
 }
@@ -300,25 +202,15 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
 
   parent_container->as.opaque = parser->mem->calloc(1, sizeof(node_table));
 
+
   set_n_table_columns(parent_container, header_row->n_columns);
 
   uint8_t *alignments =
       (uint8_t *)parser->mem->calloc(header_row->n_columns, sizeof(uint8_t));
   cmark_llist *it = marker_row->cells;
   for (i = 0; it; it = it->next, ++i) {
-    cmark_node *node = (cmark_node *)it->data;
-    assert(node->type == CMARK_NODE_TABLE_CELL);
-
-    cmark_strbuf strbuf;
-    cmark_strbuf_init(parser->mem, &strbuf, 0);
-    assert(node->first_child->type == CMARK_NODE_TEXT);
-    assert(node->first_child == node->last_child);
-    cmark_strbuf_put(&strbuf, node->first_child->as.literal.data, node->first_child->as.literal.len);
-    cmark_strbuf_trim(&strbuf);
-    char const *text = cmark_strbuf_cstr(&strbuf);
-
-    bool left = text[0] == ':', right = text[strbuf.size - 1] == ':';
-    cmark_strbuf_free(&strbuf);
+    cmark_strbuf *node = (cmark_strbuf *)it->data;
+    bool left = node->ptr[0] == ':', right = node->ptr[node->size - 1] == ':';
 
     if (left && right)
       alignments[i] = 'c';
@@ -336,9 +228,18 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
 
   table_header->as.opaque = ntr = (node_table_row *)parser->mem->calloc(1, sizeof(node_table_row));
   ntr->is_header = true;
-  ntr->raw_content_len = strlen(parent_string);
-  ntr->raw_content = (unsigned char *)malloc(ntr->raw_content_len);
-  memcpy(ntr->raw_content, parent_string, ntr->raw_content_len);
+
+  {
+    cmark_llist *tmp;
+
+    for (tmp = header_row->cells; tmp; tmp = tmp->next) {
+      cmark_strbuf *cell_buf = (cmark_strbuf *) tmp->data;
+      cmark_node *header_cell = cmark_parser_add_child(parser, table_header,
+          CMARK_NODE_TABLE_CELL, cmark_parser_get_offset(parser));
+      cmark_node_set_string_content(header_cell, (char *) cell_buf->ptr);
+      cmark_node_set_syntax_extension(header_cell, self);
+    }
+  }
 
   cmark_parser_advance_offset(
       parser, (char *)input,
@@ -354,7 +255,7 @@ static cmark_node *try_opening_table_row(cmark_syntax_extension *self,
                                          cmark_node *parent_container,
                                          unsigned char *input, int len) {
   cmark_node *table_row_block;
-  node_table_row *ntr;
+  table_row *row;
 
   if (cmark_parser_is_blank(parser))
     return NULL;
@@ -364,11 +265,31 @@ static cmark_node *try_opening_table_row(cmark_syntax_extension *self,
                              cmark_parser_get_offset(parser));
 
   cmark_node_set_syntax_extension(table_row_block, self);
-  table_row_block->as.opaque = ntr = (node_table_row *)parser->mem->calloc(1, sizeof(node_table_row));
+  table_row_block->as.opaque = parser->mem->calloc(1, sizeof(node_table_row));
+
+  row = row_from_string(self, parser, input + cmark_parser_get_first_nonspace(parser),
+      len - cmark_parser_get_first_nonspace(parser));
 
-  ntr->raw_content_len = len - cmark_parser_get_first_nonspace(parser);
-  ntr->raw_content = (unsigned char *)malloc(len);
-  memcpy(ntr->raw_content, input + cmark_parser_get_first_nonspace(parser), ntr->raw_content_len);
+  {
+    cmark_llist *tmp;
+    int i, table_columns = get_n_table_columns(parent_container);
+
+    for (tmp = row->cells, i = 0; tmp && i < table_columns; tmp = tmp->next, ++i) {
+      cmark_strbuf *cell_buf = (cmark_strbuf *) tmp->data;
+      cmark_node *cell = cmark_parser_add_child(parser, table_row_block,
+          CMARK_NODE_TABLE_CELL, cmark_parser_get_offset(parser));
+      cmark_node_set_string_content(cell, (char *) cell_buf->ptr);
+      cmark_node_set_syntax_extension(cell, self);
+    }
+
+    for (; i < table_columns; ++i) {
+      cmark_node *cell = cmark_parser_add_child(
+          parser, table_row_block, CMARK_NODE_TABLE_CELL, cmark_parser_get_offset(parser));
+      cmark_node_set_syntax_extension(cell, self);
+    }
+  }
+
+  free_table_row(parser->mem, row);
 
   cmark_parser_advance_offset(parser, (char *)input,
                               len - 1 - cmark_parser_get_offset(parser), false);
@@ -695,59 +616,11 @@ static void opaque_free(cmark_syntax_extension *self, cmark_mem *mem, cmark_node
 }
 
 static int escape(cmark_syntax_extension *self, cmark_node *node, int c) {
-  return c == '|';
-}
-
-static cmark_node *postprocess(cmark_syntax_extension *self, cmark_parser *parser, cmark_node *root) {
-  cmark_iter *iter;
-  cmark_event_type ev;
-  cmark_node *node;
-  node_table_row *ntr;
-  table_row *row;
-
-  iter = cmark_iter_new(root);
-
-  while ((ev = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
-    node = cmark_iter_get_node(iter);
-      if (ev == CMARK_EVENT_EXIT && node->type == CMARK_NODE_TABLE_ROW) {
-        ntr = (node_table_row *)node->as.opaque;
-        if (!ntr->raw_content)
-          continue;
-        row = row_from_string(self, parser,
-                              ntr->raw_content,
-                              (int)ntr->raw_content_len);
-        free(ntr->raw_content);
-        ntr->raw_content = NULL;
-        ntr->raw_content_len = 0;
-
-        {
-          cmark_llist *tmp, *next;
-          int i;
-          int table_columns = get_n_table_columns(node->parent);
-
-          for (tmp = row->cells, i = 0; tmp && i < table_columns; tmp = next, ++i) {
-            cmark_node *cell = (cmark_node *)tmp->data;
-            assert(cell->type == CMARK_NODE_TABLE_CELL);
-            cmark_node_append_child(node, cell);
-            row->cells = next = tmp->next;
-            parser->mem->free(tmp);
-          }
-
-          for (; i < table_columns; ++i) {
-            cmark_node *cell =
-                cmark_parser_add_child(parser, node, CMARK_NODE_TABLE_CELL,
-                                       cmark_parser_get_offset(parser));
-            cmark_node_set_syntax_extension(cell, self);
-          }
-        }
-
-        free_table_row(parser->mem, row);
-      }
-  }
-
-  cmark_iter_free(iter);
-
-  return root;
+  return
+    node->type != CMARK_NODE_TABLE &&
+    node->type != CMARK_NODE_TABLE_ROW &&
+    node->type != CMARK_NODE_TABLE_CELL &&
+    c == '|';
 }
 
 cmark_syntax_extension *create_table_extension(void) {
@@ -764,7 +637,6 @@ cmark_syntax_extension *create_table_extension(void) {
   cmark_syntax_extension_set_html_render_func(self, html_render);
   cmark_syntax_extension_set_opaque_free_func(self, opaque_free);
   cmark_syntax_extension_set_commonmark_escape_func(self, escape);
-  cmark_syntax_extension_set_postprocess_func(self, postprocess);
   CMARK_NODE_TABLE = cmark_syntax_extension_add_node(0);
   CMARK_NODE_TABLE_ROW = cmark_syntax_extension_add_node(0);
   CMARK_NODE_TABLE_CELL = cmark_syntax_extension_add_node(0);

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

@@ -2,9 +2,9 @@ if (NOT MSVC)
 
 include(GNUInstallDirs)
 
-  install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/man1/cmark.1
+  install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/man1/cmark-gfm.1
     DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
 
-  install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/man3/cmark.3
+  install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/man3/cmark-gfm.3
     DESTINATION ${CMAKE_INSTALL_MANDIR}/man3)
 endif(NOT MSVC)

data/ext/commonmarker/cmark/man/make_man_page.py

@@ -21,9 +21,9 @@ from ctypes import CDLL, c_char_p, c_long, c_void_p
 sysname = platform.system()
 
 if sysname == 'Darwin':
-    cmark = CDLL("build/src/libcmark.dylib")
+    cmark = CDLL("build/src/libcmark-gfm.dylib")
 else:
-    cmark = CDLL("build/src/libcmark.so")
+    cmark = CDLL("build/src/libcmark-gfm.so")
 
 parse_document = cmark.cmark_parse_document
 parse_document.restype = c_void_p
@@ -129,5 +129,5 @@ with open(sourcefile, 'r') as cmarkh:
             chunk = []
             mdlines.append('\n')
 
-sys.stdout.write('.TH ' + os.path.basename(sourcefile).replace('.h','') + ' 3 "' + date.today().strftime('%B %d, %Y') + '" "LOCAL" "Library Functions Manual"\n')
+sys.stdout.write('.TH cmark-gfm 3 "' + date.today().strftime('%B %d, %Y') + '" "LOCAL" "Library Functions Manual"\n')
 sys.stdout.write(''.join(mdlines))

data/ext/commonmarker/cmark/man/man1/{cmark.1 → cmark-gfm.1}

@@ -1,14 +1,14 @@
-.TH "cmark" "1" "March 24, 2016" "LOCAL" "General Commands Manual"
+.TH "cmark-gfm" "1" "March 24, 2016" "LOCAL" "General Commands Manual"
 .SH "NAME"
 \fBcmark\fR
-\- convert CommonMark formatted text to HTML
+\- convert CommonMark formatted text with GitHub Flavored Markdown extensions to HTML
 .SH "SYNOPSIS"
 .HP 6n
-\fBcmark\fR
+\fBcmark-gfm\fR
 [options]
 file*
 .SH "DESCRIPTION"
-\fBcmark\fR
+\fBcmark-gfm\fR
 converts Markdown formatted plain text to either HTML, groff man,
 CommonMark XML, LaTeX, or CommonMark, using the conventions
 described in the CommonMark spec.  It reads input from \fIstdin\fR
@@ -42,6 +42,12 @@ Include source position attribute.
 .B \-\-normalize
 Consolidate adjacent text nodes.
 .TP 12n
+.B \-\-extension, \-e \f[I]EXTENSION_NAME\f[]
+Specify an extension name to use.
+.TP 12n
+.B \-\-list\-extensions
+List available extensions and quit.
+.TP 12n
 .B \-\-validate-utf8
 Validate UTF-8, replacing illegal sequences with U+FFFD.
 .TP 12n

data/ext/commonmarker/cmark/man/man3/{cmark.3 → cmark-gfm.3}

@@ -1,8 +1,8 @@
-.TH cmark 3 "March 22, 2017" "LOCAL" "Library Functions Manual"
+.TH cmark-gfm 3 "April 03, 2017" "LOCAL" "Library Functions Manual"
 .SH
 NAME
 .PP
-\f[B]cmark\f[] \- CommonMark parsing, manipulating, and rendering
+\f[B]cmark\-gfm\f[] \- CommonMark parsing, manipulating, and rendering
 
 .SH
 DESCRIPTION

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

@@ -2,8 +2,8 @@ if(${CMAKE_VERSION} VERSION_GREATER "3.3")
     cmake_policy(SET CMP0063 NEW)
 endif()
 
-set(LIBRARY "libcmark")
-set(STATICLIBRARY "libcmark_static")
+set(LIBRARY "libcmark-gfm")
+set(STATICLIBRARY "libcmark-gfm_static")
 set(HEADERS
   cmark.h
   cmark_extension_api.h
@@ -52,7 +52,7 @@ set(LIBRARY_SOURCES
   ${HEADERS}
   )
 
-set(PROGRAM "cmark")
+set(PROGRAM "cmark-gfm")
 set(PROGRAM_SOURCES
   main.c
   )
@@ -70,10 +70,10 @@ include (GenerateExportHeader)
 add_executable(${PROGRAM} ${PROGRAM_SOURCES})
 add_compiler_export_flags()
 
-target_link_libraries(${PROGRAM} libcmark_static)
+target_link_libraries(${PROGRAM} libcmark-gfm_static)
 
-add_dependencies(${PROGRAM} libcmarkextensions_static)
-target_link_libraries(${PROGRAM} libcmarkextensions_static)
+add_dependencies(${PROGRAM} libcmark-gfmextensions_static)
+target_link_libraries(${PROGRAM} libcmark-gfmextensions_static)
 
 # Disable the PUBLIC declarations when compiling the executable:
 set_target_properties(${PROGRAM} PROPERTIES
@@ -99,7 +99,7 @@ if (CMARK_SHARED)
   add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES})
   # Include minor version and patch level in soname for now.
   set_target_properties(${LIBRARY} PROPERTIES
-  OUTPUT_NAME "cmark"
+  OUTPUT_NAME "cmark-gfm"
   SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}
   VERSION ${PROJECT_VERSION})
 
@@ -107,7 +107,7 @@ if (CMARK_SHARED)
     APPEND PROPERTY MACOSX_RPATH true)
 
   # Avoid name clash between PROGRAM and LIBRARY pdb files.
-  set_target_properties(${LIBRARY} PROPERTIES PDB_NAME cmark_dll)
+  set_target_properties(${LIBRARY} PROPERTIES PDB_NAME cmark-gfm_dll)
 
   generate_export_header(${LIBRARY}
     BASE_NAME ${PROJECT_NAME})
@@ -123,15 +123,15 @@ if (CMARK_STATIC)
 
   if (MSVC)
   set_target_properties(${STATICLIBRARY} PROPERTIES
-    OUTPUT_NAME "cmark_static"
+    OUTPUT_NAME "cmark-gfm_static"
     VERSION ${PROJECT_VERSION})
   else()
   set_target_properties(${STATICLIBRARY} PROPERTIES
-    OUTPUT_NAME "cmark"
+    OUTPUT_NAME "cmark-gfm"
     VERSION ${PROJECT_VERSION})
 endif(MSVC)
 
-target_link_libraries(cmark ${CMAKE_DL_LIBS})
+target_link_libraries(cmark-gfm ${CMAKE_DL_LIBS})
 
   list(APPEND CMARK_INSTALL ${STATICLIBRARY})
 endif()
@@ -139,7 +139,7 @@ set_property(TARGET ${LIBRARY}
   APPEND PROPERTY MACOSX_RPATH true)
 
 # Avoid name clash between PROGRAM and LIBRARY pdb files.
-set_target_properties(${LIBRARY} PROPERTIES PDB_NAME cmark_dll)
+set_target_properties(${LIBRARY} PROPERTIES PDB_NAME cmark-gfm_dll)
 
 generate_export_header(${LIBRARY}
     BASE_NAME ${PROJECT_NAME})
@@ -160,9 +160,9 @@ install(TARGETS ${PROGRAM} ${CMARK_INSTALL}
   )
 
 if(CMARK_SHARED OR CMARK_STATIC)
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark.pc.in
-    ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc @ONLY)
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark-gfm.pc.in
+    ${CMAKE_CURRENT_BINARY_DIR}/libcmark-gfm.pc @ONLY)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark-gfm.pc
     DESTINATION lib${LIB_SUFFIX}/pkgconfig)
 
   install(FILES

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

@@ -42,8 +42,12 @@ void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) {
   if (target_size < buf->asize)
     return;
 
-  if (target_size > (bufsize_t)(INT32_MAX / 2))
+  if (target_size > (bufsize_t)(INT32_MAX / 2)) {
+    fprintf(stderr,
+      "[cmark] cmark_strbuf_grow requests buffer with size > %d, aborting\n",
+         (INT32_MAX / 2));
     abort();
+  }
 
   /* Oversize the buffer by 50% to guarantee amortized linear time
    * complexity on append operations. */

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

@@ -16,15 +16,19 @@ const char *cmark_version_string() { return CMARK_VERSION_STRING; }
 
 static void *xcalloc(size_t nmem, size_t size) {
   void *ptr = calloc(nmem, size);
-  if (!ptr)
+  if (!ptr) {
+    fprintf(stderr, "[cmark] calloc returned null pointer, aborting\n");
     abort();
+  }
   return ptr;
 }
 
 static void *xrealloc(void *ptr, size_t size) {
   void *new_ptr = realloc(ptr, size);
-  if (!new_ptr)
+  if (!new_ptr) {
+    fprintf(stderr, "[cmark] realloc returned null pointer, aborting\n");
     abort();
+  }
   return new_ptr;
 }
 

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

@@ -11,7 +11,7 @@ extern "C" {
 
 /** # NAME
  *
- * **cmark** - CommonMark parsing, manipulating, and rendering
+ * **cmark-gfm** - CommonMark parsing, manipulating, and rendering
  */
 
 /** # DESCRIPTION

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

@@ -115,11 +115,9 @@ typedef struct delimiter {
   struct delimiter *next;
   cmark_node *inl_text;
   bufsize_t length;
-  int position;
   unsigned char delim_char;
   int can_open;
   int can_close;
-  int active;
 } delimiter;
 
 /**

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

@@ -33,8 +33,7 @@ static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_node *node,
   needs_escaping =
       c < 0x80 && escape != LITERAL &&
       ((escape == NORMAL &&
-        ((node->parent && node->parent->extension && node->parent->extension->commonmark_escape_func && node->parent->extension->commonmark_escape_func(node->extension, node->parent, c)) ||
-         c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' ||
+        (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' ||
          c == '>' || c == '\\' || c == '`' || c == '!' ||
          (c == '&' && cmark_isalpha(nextc)) || (c == '!' && nextc == '[') ||
          (renderer->begin_content && (c == '-' || c == '+' || c == '=') &&

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

@@ -1209,7 +1209,7 @@ void cmark_parse_inlines(cmark_parser *parser,
   process_emphasis(parser, &subj, NULL);
   // free bracket and delim stack
   while (subj.last_delim) {
-    pop_bracket(&subj);
+    remove_delimiter(&subj, subj.last_delim);
   }
   while (subj.last_bracket) {
     pop_bracket(&subj);

data/ext/commonmarker/cmark/src/libcmark-gfm.pc.in

@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@
+includedir=@CMAKE_INSTALL_PREFIX@/include
+
+Name: libcmark-gfm
+Description: CommonMark parsing, rendering, and manipulation with GitHub Flavored Markdown extensions
+Version: @PROJECT_VERSION@
+Libs: -L${libdir} -lcmark-gfm
+Cflags: -I${includedir}

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

@@ -28,7 +28,7 @@ typedef enum {
 } writer_format;
 
 void print_usage() {
-  printf("Usage:   cmark [FILE*]\n");
+  printf("Usage:   cmark-gfm [FILE*]\n");
   printf("Options:\n");
   printf("  --to, -t FORMAT   Specify output format (html, xml, man, "
          "commonmark, latex)\n");
@@ -40,7 +40,7 @@ void print_usage() {
   printf("  --smart           Use smart punctuation\n");
   printf("  --github-pre-lang Use GitHub-style <pre lang> for code blocks\n");
   printf("  --normalize       Consolidate adjacent text nodes\n");
-  printf("  -e, --extension EXTENSION_NAME Specify an extension name to use\n");
+  printf("  --extension, -e EXTENSION_NAME Specify an extension name to use\n");
   printf("  --list-extensions              List available extensions and quit\n");
   printf("  --help, -h        Print usage information\n");
   printf("  --version         Print version\n");