commonmarker 0.10.0 → 0.11.0

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

@@ -8,12 +8,17 @@ extern "C" {
 cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url);
 cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title);
 
-void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent,
-                         cmark_reference_map *refmap, int options);
+void cmark_parse_inlines(cmark_parser *parser,
+                         cmark_node *parent,
+                         cmark_reference_map *refmap,
+                         int options);
 
 bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_strbuf *input,
                                        cmark_reference_map *refmap);
 
+void cmark_inlines_add_special_character(unsigned char c);
+void cmark_inlines_remove_special_character(unsigned char c);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -6,12 +6,6 @@
 #include "cmark.h"
 #include "iterator.h"
 
-static const int S_leaf_mask =
-    (1 << CMARK_NODE_HTML_BLOCK) | (1 << CMARK_NODE_THEMATIC_BREAK) |
-    (1 << CMARK_NODE_CODE_BLOCK) | (1 << CMARK_NODE_TEXT) |
-    (1 << CMARK_NODE_SOFTBREAK) | (1 << CMARK_NODE_LINEBREAK) |
-    (1 << CMARK_NODE_CODE) | (1 << CMARK_NODE_HTML_INLINE);
-
 cmark_iter *cmark_iter_new(cmark_node *root) {
   if (root == NULL) {
     return NULL;
@@ -30,7 +24,18 @@ cmark_iter *cmark_iter_new(cmark_node *root) {
 void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter); }
 
 static bool S_is_leaf(cmark_node *node) {
-  return ((1 << node->type) & S_leaf_mask) != 0;
+  switch (node->type) {
+  case CMARK_NODE_HTML_BLOCK:
+  case CMARK_NODE_THEMATIC_BREAK:
+  case CMARK_NODE_CODE_BLOCK:
+  case CMARK_NODE_TEXT:
+  case CMARK_NODE_SOFTBREAK:
+  case CMARK_NODE_LINEBREAK:
+  case CMARK_NODE_CODE:
+  case CMARK_NODE_HTML_INLINE:
+    return 1;
+  }
+  return 0;
 }
 
 cmark_event_type cmark_iter_next(cmark_iter *iter) {

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

@@ -10,6 +10,7 @@
 #include "utf8.h"
 #include "scanners.h"
 #include "render.h"
+#include "syntax_extension.h"
 
 #define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
 #define LIT(s) renderer->out(renderer, s, false, LITERAL)
@@ -223,8 +224,10 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
                                   "vi", "vii", "viii", "ix",  "x"};
   bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options);
 
-  // avoid warning about unused parameter:
-  (void)(options);
+  if (node->extension && node->extension->latex_render_func) {
+    node->extension->latex_render_func(node->extension, renderer, node, ev_type, options);
+    return 1;
+  }
 
   switch (node->type) {
   case CMARK_NODE_DOCUMENT:

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

@@ -0,0 +1,37 @@
+#include <stdlib.h>
+
+#include "cmark.h"
+
+cmark_llist *cmark_llist_append(cmark_llist *head, void *data) {
+  cmark_llist *tmp;
+  cmark_llist *new_node = (cmark_llist *) malloc(sizeof(cmark_llist));
+
+  new_node->data = data;
+  new_node->next = NULL;
+
+  if (!head)
+    return new_node;
+
+  for (tmp = head; tmp->next; tmp=tmp->next);
+
+  tmp->next = new_node;
+
+  return head;
+}
+
+void cmark_llist_free_full(cmark_llist *head, cmark_free_func free_func) {
+  cmark_llist *tmp, *prev;
+
+  for (tmp = head; tmp;) {
+    if (free_func)
+      free_func(tmp->data);
+
+    prev = tmp;
+    tmp = tmp->next;
+    free(prev);
+  }
+}
+
+void cmark_llist_free(cmark_llist *head) {
+  cmark_llist_free_full(head, NULL);
+}

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

@@ -5,6 +5,12 @@
 #include "config.h"
 #include "memory.h"
 #include "cmark.h"
+#include "cmark_extension_api.h"
+#include "syntax_extension.h"
+#include "parser.h"
+#include "registry.h"
+
+#include "../extensions/core-extensions.h"
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
 #include <io.h>
@@ -23,26 +29,28 @@ typedef enum {
 void print_usage() {
   printf("Usage:   cmark [FILE*]\n");
   printf("Options:\n");
-  printf("  --to, -t FORMAT  Specify output format (html, xml, man, "
+  printf("  --to, -t FORMAT                Specify output format (html, xml, man, "
          "commonmark, latex)\n");
-  printf("  --width WIDTH    Specify wrap width (default 0 = nowrap)\n");
-  printf("  --sourcepos      Include source position attribute\n");
-  printf("  --hardbreaks     Treat newlines as hard line breaks\n");
+  printf("  --width WIDTH                  Specify wrap width (default 0 = nowrap)\n");
+  printf("  --sourcepos                    Include source position attribute\n");
+  printf("  --hardbreaks                   Treat newlines as hard line breaks\n");
   printf("  --nobreaks       Render soft line breaks as spaces\n");
-  printf("  --safe           Suppress raw HTML and dangerous URLs\n");
-  printf("  --smart          Use smart punctuation\n");
-  printf("  --normalize      Consolidate adjacent text nodes\n");
-  printf("  --help, -h       Print usage information\n");
-  printf("  --version        Print version\n");
+  printf("  --safe                         Suppress raw HTML and dangerous URLs\n");
+  printf("  --smart                        Use smart punctuation\n");
+  printf("  --normalize                    Consolidate adjacent text nodes\n");
+  printf("  -e, --extension 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");
 }
 
-static void print_document(cmark_node *document, writer_format writer,
-                           int options, int width) {
+static bool print_document(cmark_node *document, writer_format writer,
+                           int options, int width, cmark_parser *parser) {
   char *result;
 
   switch (writer) {
   case FORMAT_HTML:
-    result = cmark_render_html(document, options);
+    result = cmark_render_html(document, options, parser->syntax_extensions);
     break;
   case FORMAT_XML:
     result = cmark_render_xml(document, options);
@@ -58,23 +66,44 @@ static void print_document(cmark_node *document, writer_format writer,
     break;
   default:
     fprintf(stderr, "Unknown format %d\n", writer);
-    exit(1);
+    return false;
   }
+
   printf("%s", result);
   free(result);
+
+  return true;
+}
+
+static void print_extensions(void) {
+  cmark_llist *syntax_extensions;
+  cmark_llist *tmp;
+
+  printf ("Available extensions:\n");
+
+  syntax_extensions = cmark_list_syntax_extensions();
+  for (tmp = syntax_extensions; tmp; tmp=tmp->next) {
+    cmark_syntax_extension *ext = (cmark_syntax_extension *) tmp->data;
+    printf("%s\n", ext->name);
+  }
+
+  cmark_llist_free(syntax_extensions);
 }
 
 int main(int argc, char *argv[]) {
   int i, numfps = 0;
   int *files;
   char buffer[4096];
-  cmark_parser *parser;
+  cmark_parser *parser = NULL;
   size_t bytes;
-  cmark_node *document;
+  cmark_node *document = NULL;
   int width = 0;
   char *unparsed;
   writer_format writer = FORMAT_HTML;
   int options = CMARK_OPT_DEFAULT;
+  int res = 1;
+
+  cmark_register_plugin(core_extensions_registration);
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
   _setmode(_fileno(stdin), _O_BINARY);
@@ -87,7 +116,10 @@ int main(int argc, char *argv[]) {
     if (strcmp(argv[i], "--version") == 0) {
       printf("cmark %s", CMARK_VERSION_STRING);
       printf(" - CommonMark converter\n(C) 2014-2016 John MacFarlane\n");
-      exit(0);
+      goto success;
+    } else if (strcmp(argv[i], "--list-extensions") == 0) {
+      print_extensions();
+      goto success;
     } else if (strcmp(argv[i], "--sourcepos") == 0) {
       options |= CMARK_OPT_SOURCEPOS;
     } else if (strcmp(argv[i], "--hardbreaks") == 0) {
@@ -105,7 +137,7 @@ int main(int argc, char *argv[]) {
     } else if ((strcmp(argv[i], "--help") == 0) ||
                (strcmp(argv[i], "-h") == 0)) {
       print_usage();
-      exit(0);
+      goto success;
     } else if (strcmp(argv[i], "--width") == 0) {
       i += 1;
       if (i < argc) {
@@ -113,11 +145,11 @@ int main(int argc, char *argv[]) {
         if (unparsed && strlen(unparsed) > 0) {
           fprintf(stderr, "failed parsing width '%s' at '%s'\n", argv[i],
                   unparsed);
-          exit(1);
+          goto failure;
         }
       } else {
         fprintf(stderr, "--width requires an argument\n");
-        exit(1);
+        goto failure;
       }
     } else if ((strcmp(argv[i], "-t") == 0) || (strcmp(argv[i], "--to") == 0)) {
       i += 1;
@@ -134,27 +166,48 @@ int main(int argc, char *argv[]) {
           writer = FORMAT_LATEX;
         } else {
           fprintf(stderr, "Unknown format %s\n", argv[i]);
-          exit(1);
+          goto failure;
         }
       } else {
         fprintf(stderr, "No argument provided for %s\n", argv[i - 1]);
-        exit(1);
+        goto failure;
       }
+    } else if ((strcmp(argv[i], "-e") == 0) || (strcmp(argv[i], "--extension") == 0)) {
+      i += 1; // Simpler to handle extensions in a second pass, as we can directly register
+              // them with the parser.
     } else if (*argv[i] == '-') {
       print_usage();
-      exit(1);
+      goto failure;
     } else { // treat as file argument
       files[numfps++] = i;
     }
   }
 
   parser = cmark_parser_new(options);
+
+  for (i = 1; i < argc; i++) {
+    if ((strcmp(argv[i], "-e") == 0) || (strcmp(argv[i], "--extension") == 0)) {
+      i += 1;
+      if (i < argc) {
+        cmark_syntax_extension *syntax_extension = cmark_find_syntax_extension(argv[i]);
+        if (!syntax_extension) {
+          fprintf(stderr, "Unknown extension %s\n", argv[i]);
+          goto failure;
+        }
+        cmark_parser_attach_syntax_extension(parser, syntax_extension);
+      } else {
+        fprintf(stderr, "No argument provided for %s\n", argv[i - 1]);
+        goto failure;
+      }
+    }
+  }
+
   for (i = 0; i < numfps; i++) {
     FILE *fp = fopen(argv[files[i]], "rb");
     if (fp == NULL) {
       fprintf(stderr, "Error opening file %s: %s\n", argv[files[i]],
               strerror(errno));
-      exit(1);
+      goto failure;
     }
 
     while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
@@ -178,13 +231,24 @@ int main(int argc, char *argv[]) {
   }
 
   document = cmark_parser_finish(parser);
-  cmark_parser_free(parser);
 
-  print_document(document, writer, options, width);
+  if (!print_document(document, writer, options, width, parser))
+    goto failure;
+
+
+success:
+  res = 0;
+
+failure:
+  if (parser)
+    cmark_parser_free(parser);
+
+  if (document)
+    cmark_node_free(document);
 
-  cmark_node_free(document);
+  cmark_release_plugins();
 
   free(files);
 
-  return 0;
+  return res;
 }

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

@@ -9,6 +9,7 @@
 #include "buffer.h"
 #include "utf8.h"
 #include "render.h"
+#include "syntax_extension.h"
 
 #define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
 #define LIT(s) renderer->out(renderer, s, false, LITERAL)
@@ -77,11 +78,26 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
   bool entering = (ev_type == CMARK_EVENT_ENTER);
   bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options);
 
-  // avoid unused parameter error:
-  (void)(options);
+  if (node->extension && node->extension->man_render_func) {
+    node->extension->man_render_func(node->extension, renderer, node, ev_type, options);
+    return 1;
+  }
 
   switch (node->type) {
   case CMARK_NODE_DOCUMENT:
+    if (entering) {
+      /* Define a strikethrough macro */
+      /* Commenting out because this makes tests fail
+      LIT(".de ST");
+      CR();
+      LIT(".nr ww \\w'\\\\$1'");
+      CR();
+      LIT("\\Z@\\v'-.25m'\\l'\\\\n[ww]u'@\\\\$1");
+      CR();
+      LIT("..");
+      CR();
+      */
+    }
     break;
 
   case CMARK_NODE_BLOCK_QUOTE:

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

@@ -3,55 +3,29 @@
 
 #include "config.h"
 #include "node.h"
+#include "syntax_extension.h"
 
 static void S_node_unlink(cmark_node *node);
 
 #define NODE_MEM(node) cmark_node_mem(node)
 
-static CMARK_INLINE bool S_is_block(cmark_node *node) {
-  if (node == NULL) {
+bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type) {
+  if (child_type == CMARK_NODE_DOCUMENT) {
     return false;
   }
-  return node->type >= CMARK_NODE_FIRST_BLOCK &&
-         node->type <= CMARK_NODE_LAST_BLOCK;
-}
 
-static CMARK_INLINE bool S_is_inline(cmark_node *node) {
-  if (node == NULL) {
-    return false;
-  }
-  return node->type >= CMARK_NODE_FIRST_INLINE &&
-         node->type <= CMARK_NODE_LAST_INLINE;
-}
-
-static bool S_can_contain(cmark_node *node, cmark_node *child) {
-  cmark_node *cur;
-
-  if (node == NULL || child == NULL) {
-    return false;
-  }
-
-  // Verify that child is not an ancestor of node or equal to node.
-  cur = node;
-  do {
-    if (cur == child) {
-      return false;
-    }
-    cur = cur->parent;
-  } while (cur != NULL);
-
-  if (child->type == CMARK_NODE_DOCUMENT) {
-    return false;
+  if (node->extension && node->extension->can_contain_func) {
+    return node->extension->can_contain_func(node->extension, node, child_type);
   }
 
   switch (node->type) {
   case CMARK_NODE_DOCUMENT:
   case CMARK_NODE_BLOCK_QUOTE:
   case CMARK_NODE_ITEM:
-    return S_is_block(child) && child->type != CMARK_NODE_ITEM;
+    return CMARK_NODE_TYPE_BLOCK_P(child_type) && child_type != CMARK_NODE_ITEM;
 
   case CMARK_NODE_LIST:
-    return child->type == CMARK_NODE_ITEM;
+    return child_type == CMARK_NODE_ITEM;
 
   case CMARK_NODE_CUSTOM_BLOCK:
     return true;
@@ -63,7 +37,7 @@ static bool S_can_contain(cmark_node *node, cmark_node *child) {
   case CMARK_NODE_LINK:
   case CMARK_NODE_IMAGE:
   case CMARK_NODE_CUSTOM_INLINE:
-    return S_is_inline(child);
+    return CMARK_NODE_TYPE_INLINE_P(child_type);
 
   default:
     break;
@@ -72,6 +46,28 @@ static bool S_can_contain(cmark_node *node, cmark_node *child) {
   return false;
 }
 
+static bool S_can_contain(cmark_node *node, cmark_node *child) {
+  cmark_node *cur;
+
+  if (node == NULL || child == NULL) {
+    return false;
+  }
+  if (NODE_MEM(node) != NODE_MEM(child)) {
+    return 0;
+  }
+
+  // Verify that child is not an ancestor of node or equal to node.
+  cur = node;
+  do {
+    if (cur == child) {
+      return false;
+    }
+    cur = cur->parent;
+  } while (cur != NULL);
+
+  return cmark_node_can_contain_type(node, (cmark_node_type) child->type);
+}
+
 cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) {
   cmark_node *node = (cmark_node *)mem->calloc(1, sizeof(*node));
   cmark_strbuf_init(mem, &node->content, 0);
@@ -102,35 +98,44 @@ cmark_node *cmark_node_new(cmark_node_type type) {
   return cmark_node_new_with_mem(type, &DEFAULT_MEM_ALLOCATOR);
 }
 
+static void free_node_as(cmark_node *node) {
+  switch (node->type) {
+  case CMARK_NODE_CODE_BLOCK:
+    cmark_chunk_free(NODE_MEM(node), &node->as.code.info);
+    cmark_chunk_free(NODE_MEM(node), &node->as.code.literal);
+    break;
+  case CMARK_NODE_TEXT:
+  case CMARK_NODE_HTML_INLINE:
+  case CMARK_NODE_CODE:
+  case CMARK_NODE_HTML_BLOCK:
+    cmark_chunk_free(NODE_MEM(node), &node->as.literal);
+    break;
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+    cmark_chunk_free(NODE_MEM(node), &node->as.link.url);
+    cmark_chunk_free(NODE_MEM(node), &node->as.link.title);
+    break;
+  case CMARK_NODE_CUSTOM_BLOCK:
+  case CMARK_NODE_CUSTOM_INLINE:
+    cmark_chunk_free(NODE_MEM(node), &node->as.custom.on_enter);
+    cmark_chunk_free(NODE_MEM(node), &node->as.custom.on_exit);
+    break;
+  default:
+    break;
+  }
+}
+
 // Free a cmark_node list and any children.
 static void S_free_nodes(cmark_node *e) {
   cmark_node *next;
   while (e != NULL) {
     cmark_strbuf_free(&e->content);
-    switch (e->type) {
-    case CMARK_NODE_CODE_BLOCK:
-      cmark_chunk_free(NODE_MEM(e), &e->as.code.info);
-      cmark_chunk_free(NODE_MEM(e), &e->as.code.literal);
-      break;
-    case CMARK_NODE_TEXT:
-    case CMARK_NODE_HTML_INLINE:
-    case CMARK_NODE_CODE:
-    case CMARK_NODE_HTML_BLOCK:
-      cmark_chunk_free(NODE_MEM(e), &e->as.literal);
-      break;
-    case CMARK_NODE_LINK:
-    case CMARK_NODE_IMAGE:
-      cmark_chunk_free(NODE_MEM(e), &e->as.link.url);
-      cmark_chunk_free(NODE_MEM(e), &e->as.link.title);
-      break;
-    case CMARK_NODE_CUSTOM_BLOCK:
-    case CMARK_NODE_CUSTOM_INLINE:
-      cmark_chunk_free(NODE_MEM(e), &e->as.custom.on_enter);
-      cmark_chunk_free(NODE_MEM(e), &e->as.custom.on_exit);
-      break;
-    default:
-      break;
-    }
+
+    if (e->user_data && e->user_data_free_func)
+      e->user_data_free_func(e->user_data);
+
+    free_node_as(e);
+
     if (e->last_child) {
       // Splice children into list
       e->last_child->next = e->next;
@@ -156,11 +161,38 @@ cmark_node_type cmark_node_get_type(cmark_node *node) {
   }
 }
 
+int cmark_node_set_type(cmark_node * node, cmark_node_type type) {
+  cmark_node_type initial_type;
+
+  if (type == node->type)
+    return 1;
+
+  initial_type = (cmark_node_type) node->type;
+  node->type = type;
+
+  if (!S_can_contain(node->parent, node)) {
+    node->type = initial_type;
+    return 0;
+  }
+
+  /* We rollback the type to free the union members appropriately */
+  node->type = initial_type;
+  free_node_as(node);
+
+  node->type = type;
+
+  return 1;
+}
+
 const char *cmark_node_get_type_string(cmark_node *node) {
   if (node == NULL) {
     return "NONE";
   }
 
+  if (node->extension && node->extension->get_type_string_func) {
+    return node->extension->get_type_string_func(node->extension, node);
+  }
+
   switch (node->type) {
   case CMARK_NODE_NONE:
     return "none";
@@ -265,6 +297,15 @@ int cmark_node_set_user_data(cmark_node *node, void *user_data) {
   return 1;
 }
 
+int cmark_node_set_user_data_free_func(cmark_node *node,
+                                        cmark_free_func free_func) {
+  if (node == NULL) {
+    return 0;
+  }
+  node->user_data_free_func = free_func;
+  return 1;
+}
+
 const char *cmark_node_get_literal(cmark_node *node) {
   if (node == NULL) {
     return NULL;
@@ -311,6 +352,15 @@ int cmark_node_set_literal(cmark_node *node, const char *content) {
   return 0;
 }
 
+const char *cmark_node_get_string_content(cmark_node *node) {
+  return (char *) node->content.ptr;
+}
+
+int cmark_node_set_string_content(cmark_node *node, const char *content) {
+  cmark_strbuf_sets(&node->content, content);
+  return true;
+}
+
 int cmark_node_get_heading_level(cmark_node *node) {
   if (node == NULL) {
     return 0;
@@ -477,6 +527,38 @@ int cmark_node_set_fence_info(cmark_node *node, const char *info) {
   }
 }
 
+int cmark_node_get_fenced(cmark_node *node, int *length, int *offset, char *character) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_CODE_BLOCK) {
+    *length = node->as.code.fence_length;
+    *offset = node->as.code.fence_offset;
+    *character = node->as.code.fence_char;
+    return node->as.code.fenced;
+  } else {
+    return 0;
+  }
+}
+
+int cmark_node_set_fenced(cmark_node * node, int fenced,
+    int length, int offset, char character) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_CODE_BLOCK) {
+    node->as.code.fenced = fenced;
+    node->as.code.fence_length = length;
+    node->as.code.fence_offset = offset;
+    node->as.code.fence_char = character;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
 const char *cmark_node_get_url(cmark_node *node) {
   if (node == NULL) {
     return NULL;
@@ -609,6 +691,23 @@ int cmark_node_set_on_exit(cmark_node *node, const char *on_exit) {
   return 0;
 }
 
+cmark_syntax_extension *cmark_node_get_syntax_extension(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  return node->extension;
+}
+
+int cmark_node_set_syntax_extension(cmark_node *node, cmark_syntax_extension *extension) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  node->extension = extension;
+  return 1;
+}
+
 int cmark_node_get_start_line(cmark_node *node) {
   if (node == NULL) {
     return 0;