commonmarker 0.14.15 → 0.15.0

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

@@ -8,8 +8,14 @@ extern "C" {
 bufsize_t _ext_scan_at(bufsize_t (*scanner)(const unsigned char *),
                        unsigned char *ptr, int len, bufsize_t offset);
 bufsize_t _scan_table_start(const unsigned char *p);
+bufsize_t _scan_table_cell(const unsigned char *p);
+bufsize_t _scan_table_cell_end(const unsigned char *p);
+bufsize_t _scan_table_row_end(const unsigned char *p);
 
 #define scan_table_start(c, l, n) _ext_scan_at(&_scan_table_start, c, l, n)
+#define scan_table_cell(c, l, n) _ext_scan_at(&_scan_table_cell, c, l, n)
+#define scan_table_cell_end(c, l, n) _ext_scan_at(&_scan_table_cell_end, c, l, n)
+#define scan_table_row_end(c, l, n) _ext_scan_at(&_scan_table_row_end, c, l, n)
 
 #ifdef __cplusplus
 }

data/ext/commonmarker/cmark/extensions/ext_scanners.re

@@ -27,8 +27,10 @@ bufsize_t _ext_scan_at(bufsize_t (*scanner)(const unsigned char *), unsigned cha
 
   spacechar = [ \t\v\f];
   newline = [\r]?[\n];
+  escaped_char = [\\][|!"#$%&'()*+,./:;<=>?@[\\\]^_`{}~-];
 
   table_marker = (spacechar*[:]?[-]+[:]?spacechar*);
+  table_cell = (escaped_char|[^|\r\n])*;
 */
 
 bufsize_t _scan_table_start(const unsigned char *p)
@@ -40,3 +42,33 @@ bufsize_t _scan_table_start(const unsigned char *p)
   .? { return 0; }
 */
 }
+
+bufsize_t _scan_table_cell(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  table_cell { return (bufsize_t)(p - start); }
+  .? { return 0; }
+*/
+}
+
+bufsize_t _scan_table_cell_end(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [|] spacechar* newline? { return (bufsize_t)(p - start); }
+  .? { return 0; }
+*/
+}
+
+bufsize_t _scan_table_row_end(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  spacechar* newline { return (bufsize_t)(p - start); }
+  .? { return 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)