commonmarker 0.5.1 → 0.6.0

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

@@ -24,7 +24,7 @@ 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_INLINE_HTML, 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)
@@ -284,7 +284,7 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open,
       before_char_pos -= 1;
     }
     len = cmark_utf8proc_iterate(subj->input.data + before_char_pos,
-                           subj->pos - before_char_pos, &before_char);
+                                 subj->pos - before_char_pos, &before_char);
     if (len == -1) {
       before_char = 10;
     }
@@ -301,7 +301,7 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open,
   }
 
   len = cmark_utf8proc_iterate(subj->input.data + subj->pos,
-                         subj->input.len - subj->pos, &after_char);
+                               subj->input.len - subj->pos, &after_char);
   if (len == -1) {
     after_char = 10;
   }
@@ -309,10 +309,10 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open,
                   !(cmark_utf8proc_is_punctuation(after_char) &&
                     !cmark_utf8proc_is_space(before_char) &&
                     !cmark_utf8proc_is_punctuation(before_char));
-  right_flanking =
-      numdelims > 0 && !cmark_utf8proc_is_space(before_char) &&
-      !(cmark_utf8proc_is_punctuation(before_char) &&
-        !cmark_utf8proc_is_space(after_char) && !cmark_utf8proc_is_punctuation(after_char));
+  right_flanking = numdelims > 0 && !cmark_utf8proc_is_space(before_char) &&
+                   !(cmark_utf8proc_is_punctuation(before_char) &&
+                     !cmark_utf8proc_is_space(after_char) &&
+                     !cmark_utf8proc_is_punctuation(after_char));
   if (c == '_') {
     *can_open = left_flanking &&
                 (!right_flanking || cmark_utf8proc_is_punctuation(before_char));
@@ -865,7 +865,6 @@ static cmark_node *handle_close_bracket(subject *subj, cmark_node *parent) {
 
   // Next, look for a following [link label] that matches in refmap.
   // skip spaces
-  subj->pos = subj->pos + scan_spacechars(&subj->input, subj->pos);
   raw_label = cmark_chunk_literal("");
   found_label = link_label(subj, &raw_label);
   if (!found_label || raw_label.len == 0) {
@@ -944,10 +943,10 @@ static cmark_node *handle_newline(subject *subj) {
   bufsize_t nlpos = subj->pos;
   // skip over cr, crlf, or lf:
   if (peek_at(subj, subj->pos) == '\r') {
-	  advance(subj);
+    advance(subj);
   }
   if (peek_at(subj, subj->pos) == '\n') {
-	  advance(subj);
+    advance(subj);
   }
   // skip spaces at beginning of line
   skip_spaces(subj);

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

@@ -7,10 +7,10 @@
 #include "iterator.h"
 
 static const int S_leaf_mask =
-    (1 << CMARK_NODE_HTML) | (1 << CMARK_NODE_HRULE) |
+    (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_INLINE_HTML);
+    (1 << CMARK_NODE_CODE) | (1 << CMARK_NODE_HTML_INLINE);
 
 cmark_iter *cmark_iter_new(cmark_node *root) {
   if (root == NULL) {

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

@@ -142,7 +142,13 @@ static inline void outc(cmark_renderer *renderer, cmark_escaping escape,
   }
 }
 
-typedef enum { NO_LINK, URL_AUTOLINK, EMAIL_AUTOLINK, NORMAL_LINK } link_type;
+typedef enum {
+  NO_LINK,
+  URL_AUTOLINK,
+  EMAIL_AUTOLINK,
+  NORMAL_LINK,
+  INTERNAL_LINK
+} link_type;
 
 static link_type get_link_type(cmark_node *node) {
   size_t title_len, url_len;
@@ -158,6 +164,10 @@ static link_type get_link_type(cmark_node *node) {
   const char *url = cmark_node_get_url(node);
   cmark_chunk url_chunk = cmark_chunk_literal(url);
 
+  if (url && *url == '#') {
+    return INTERNAL_LINK;
+  }
+
   url_len = safe_strlen(url);
   if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) {
     return NO_LINK;
@@ -166,30 +176,29 @@ static link_type get_link_type(cmark_node *node) {
   const char *title = cmark_node_get_title(node);
   title_len = safe_strlen(title);
   // if it has a title, we can't treat it as an autolink:
-  if (title_len > 0) {
-    return NORMAL_LINK;
-  }
-
-  link_text = node->first_child;
-  cmark_consolidate_text_nodes(link_text);
-  realurl = (char *)url;
-  realurllen = url_len;
-  if (strncmp(realurl, "mailto:", 7) == 0) {
-    realurl += 7;
-    realurllen -= 7;
-    isemail = true;
-  }
-  if (realurllen == link_text->as.literal.len &&
-      strncmp(realurl, (char *)link_text->as.literal.data,
-              link_text->as.literal.len) == 0) {
-    if (isemail) {
-      return EMAIL_AUTOLINK;
-    } else {
-      return URL_AUTOLINK;
+  if (title_len == 0) {
+
+    link_text = node->first_child;
+    cmark_consolidate_text_nodes(link_text);
+    realurl = (char *)url;
+    realurllen = url_len;
+    if (strncmp(realurl, "mailto:", 7) == 0) {
+      realurl += 7;
+      realurllen -= 7;
+      isemail = true;
+    }
+    if (realurllen == link_text->as.literal.len &&
+        strncmp(realurl, (char *)link_text->as.literal.data,
+                link_text->as.literal.len) == 0) {
+      if (isemail) {
+        return EMAIL_AUTOLINK;
+      } else {
+        return URL_AUTOLINK;
+      }
     }
-  } else {
-    return NORMAL_LINK;
   }
+
+  return NORMAL_LINK;
 }
 
 static int S_get_enumlevel(cmark_node *node) {
@@ -264,9 +273,9 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     }
     break;
 
-  case CMARK_NODE_HEADER:
+  case CMARK_NODE_HEADING:
     if (entering) {
-      switch (cmark_node_get_header_level(node)) {
+      switch (cmark_node_get_heading_level(node)) {
       case 1:
         LIT("\\section");
         break;
@@ -300,10 +309,17 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     BLANKLINE();
     break;
 
-  case CMARK_NODE_HTML:
+  case CMARK_NODE_HTML_BLOCK:
     break;
 
-  case CMARK_NODE_HRULE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    CR();
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    CR();
+    break;
+
+  case CMARK_NODE_THEMATIC_BREAK:
     BLANKLINE();
     LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}");
     BLANKLINE();
@@ -338,7 +354,12 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     LIT("}");
     break;
 
-  case CMARK_NODE_INLINE_HTML:
+  case CMARK_NODE_HTML_INLINE:
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE:
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
     break;
 
   case CMARK_NODE_STRONG:
@@ -376,6 +397,11 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
         OUT(url, false, URL);
         LIT("}{");
         break;
+      case INTERNAL_LINK:
+        LIT("\\protect\\hyperlink{");
+        OUT(url + 1, false, URL);
+        LIT("}{");
+        break;
       case NO_LINK:
         LIT("{"); // error?
       }

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

@@ -4,7 +4,6 @@
 #include <errno.h>
 #include "config.h"
 #include "cmark.h"
-#include "bench.h"
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
 #include <io.h>
@@ -153,14 +152,12 @@ int main(int argc, char *argv[]) {
       exit(1);
     }
 
-    start_timer();
     while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
       cmark_parser_feed(parser, buffer, bytes);
       if (bytes < sizeof(buffer)) {
         break;
       }
     }
-    end_timer("processing lines");
 
     fclose(fp);
   }
@@ -175,18 +172,12 @@ int main(int argc, char *argv[]) {
     }
   }
 
-  start_timer();
   document = cmark_parser_finish(parser);
-  end_timer("finishing document");
   cmark_parser_free(parser);
 
-  start_timer();
   print_document(document, writer, options, width);
-  end_timer("print_document");
 
-  start_timer();
   cmark_node_free(document);
-  end_timer("free_blocks");
 
   free(files);
 

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

@@ -120,10 +120,10 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     }
     break;
 
-  case CMARK_NODE_HEADER:
+  case CMARK_NODE_HEADING:
     if (entering) {
       CR();
-      LIT(cmark_node_get_header_level(node) == 1 ? ".SH" : ".SS");
+      LIT(cmark_node_get_heading_level(node) == 1 ? ".SH" : ".SS");
       CR();
     } else {
       CR();
@@ -139,10 +139,17 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     CR();
     break;
 
-  case CMARK_NODE_HTML:
+  case CMARK_NODE_HTML_BLOCK:
     break;
 
-  case CMARK_NODE_HRULE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    CR();
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    CR();
+    break;
+
+  case CMARK_NODE_THEMATIC_BREAK:
     CR();
     LIT(".PP\n  *  *  *  *  *");
     CR();
@@ -187,7 +194,12 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     LIT("\\f[]");
     break;
 
-  case CMARK_NODE_INLINE_HTML:
+  case CMARK_NODE_HTML_INLINE:
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE:
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
     break;
 
   case CMARK_NODE_STRONG:

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

@@ -51,12 +51,16 @@ static bool S_can_contain(cmark_node *node, cmark_node *child) {
   case CMARK_NODE_LIST:
     return child->type == CMARK_NODE_ITEM;
 
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return true;
+
   case CMARK_NODE_PARAGRAPH:
-  case CMARK_NODE_HEADER:
+  case CMARK_NODE_HEADING:
   case CMARK_NODE_EMPH:
   case CMARK_NODE_STRONG:
   case CMARK_NODE_LINK:
   case CMARK_NODE_IMAGE:
+  case CMARK_NODE_CUSTOM_INLINE:
     return S_is_inline(child);
 
   default:
@@ -71,8 +75,8 @@ cmark_node *cmark_node_new(cmark_node_type type) {
   node->type = type;
 
   switch (node->type) {
-  case CMARK_NODE_HEADER:
-    node->as.header.level = 1;
+  case CMARK_NODE_HEADING:
+    node->as.heading.level = 1;
     break;
 
   case CMARK_NODE_LIST: {
@@ -98,21 +102,26 @@ static void S_free_nodes(cmark_node *e) {
       cmark_strbuf_free(&e->string_content);
     }
     switch (e->type) {
-    case NODE_CODE_BLOCK:
+    case CMARK_NODE_CODE_BLOCK:
       cmark_chunk_free(&e->as.code.info);
       cmark_chunk_free(&e->as.code.literal);
       break;
-    case NODE_TEXT:
-    case NODE_INLINE_HTML:
-    case NODE_CODE:
-    case NODE_HTML:
+    case CMARK_NODE_TEXT:
+    case CMARK_NODE_HTML_INLINE:
+    case CMARK_NODE_CODE:
+    case CMARK_NODE_HTML_BLOCK:
       cmark_chunk_free(&e->as.literal);
       break;
-    case NODE_LINK:
-    case NODE_IMAGE:
+    case CMARK_NODE_LINK:
+    case CMARK_NODE_IMAGE:
       cmark_chunk_free(&e->as.link.url);
       cmark_chunk_free(&e->as.link.title);
       break;
+    case CMARK_NODE_CUSTOM_BLOCK:
+    case CMARK_NODE_CUSTOM_INLINE:
+      cmark_chunk_free(&e->as.custom.on_enter);
+      cmark_chunk_free(&e->as.custom.on_exit);
+      break;
     default:
       break;
     }
@@ -159,14 +168,16 @@ const char *cmark_node_get_type_string(cmark_node *node) {
     return "item";
   case CMARK_NODE_CODE_BLOCK:
     return "code_block";
-  case CMARK_NODE_HTML:
-    return "html";
+  case CMARK_NODE_HTML_BLOCK:
+    return "html_block";
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return "raw_block";
   case CMARK_NODE_PARAGRAPH:
     return "paragraph";
-  case CMARK_NODE_HEADER:
-    return "header";
-  case CMARK_NODE_HRULE:
-    return "hrule";
+  case CMARK_NODE_HEADING:
+    return "heading";
+  case CMARK_NODE_THEMATIC_BREAK:
+    return "thematic_break";
   case CMARK_NODE_TEXT:
     return "text";
   case CMARK_NODE_SOFTBREAK:
@@ -175,8 +186,10 @@ const char *cmark_node_get_type_string(cmark_node *node) {
     return "linebreak";
   case CMARK_NODE_CODE:
     return "code";
-  case CMARK_NODE_INLINE_HTML:
-    return "inline_html";
+  case CMARK_NODE_HTML_INLINE:
+    return "html_inline";
+  case CMARK_NODE_CUSTOM_INLINE:
+    return "raw_inline";
   case CMARK_NODE_EMPH:
     return "emph";
   case CMARK_NODE_STRONG:
@@ -252,13 +265,13 @@ const char *cmark_node_get_literal(cmark_node *node) {
   }
 
   switch (node->type) {
-  case NODE_HTML:
-  case NODE_TEXT:
-  case NODE_INLINE_HTML:
-  case NODE_CODE:
+  case CMARK_NODE_HTML_BLOCK:
+  case CMARK_NODE_TEXT:
+  case CMARK_NODE_HTML_INLINE:
+  case CMARK_NODE_CODE:
     return cmark_chunk_to_cstr(&node->as.literal);
 
-  case NODE_CODE_BLOCK:
+  case CMARK_NODE_CODE_BLOCK:
     return cmark_chunk_to_cstr(&node->as.code.literal);
 
   default:
@@ -274,14 +287,14 @@ int cmark_node_set_literal(cmark_node *node, const char *content) {
   }
 
   switch (node->type) {
-  case NODE_HTML:
-  case NODE_TEXT:
-  case NODE_INLINE_HTML:
-  case NODE_CODE:
+  case CMARK_NODE_HTML_BLOCK:
+  case CMARK_NODE_TEXT:
+  case CMARK_NODE_HTML_INLINE:
+  case CMARK_NODE_CODE:
     cmark_chunk_set_cstr(&node->as.literal, content);
     return 1;
 
-  case NODE_CODE_BLOCK:
+  case CMARK_NODE_CODE_BLOCK:
     cmark_chunk_set_cstr(&node->as.code.literal, content);
     return 1;
 
@@ -292,14 +305,14 @@ int cmark_node_set_literal(cmark_node *node, const char *content) {
   return 0;
 }
 
-int cmark_node_get_header_level(cmark_node *node) {
+int cmark_node_get_heading_level(cmark_node *node) {
   if (node == NULL) {
     return 0;
   }
 
   switch (node->type) {
-  case CMARK_NODE_HEADER:
-    return node->as.header.level;
+  case CMARK_NODE_HEADING:
+    return node->as.heading.level;
 
   default:
     break;
@@ -308,14 +321,14 @@ int cmark_node_get_header_level(cmark_node *node) {
   return 0;
 }
 
-int cmark_node_set_header_level(cmark_node *node, int level) {
+int cmark_node_set_heading_level(cmark_node *node, int level) {
   if (node == NULL || level < 1 || level > 6) {
     return 0;
   }
 
   switch (node->type) {
-  case CMARK_NODE_HEADER:
-    node->as.header.level = level;
+  case CMARK_NODE_HEADING:
+    node->as.heading.level = level;
     return 1;
 
   default:
@@ -438,7 +451,7 @@ const char *cmark_node_get_fence_info(cmark_node *node) {
     return NULL;
   }
 
-  if (node->type == NODE_CODE_BLOCK) {
+  if (node->type == CMARK_NODE_CODE_BLOCK) {
     return cmark_chunk_to_cstr(&node->as.code.info);
   } else {
     return NULL;
@@ -450,7 +463,7 @@ int cmark_node_set_fence_info(cmark_node *node, const char *info) {
     return 0;
   }
 
-  if (node->type == NODE_CODE_BLOCK) {
+  if (node->type == CMARK_NODE_CODE_BLOCK) {
     cmark_chunk_set_cstr(&node->as.code.info, info);
     return 1;
   } else {
@@ -464,8 +477,8 @@ const char *cmark_node_get_url(cmark_node *node) {
   }
 
   switch (node->type) {
-  case NODE_LINK:
-  case NODE_IMAGE:
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
     return cmark_chunk_to_cstr(&node->as.link.url);
   default:
     break;
@@ -480,8 +493,8 @@ int cmark_node_set_url(cmark_node *node, const char *url) {
   }
 
   switch (node->type) {
-  case NODE_LINK:
-  case NODE_IMAGE:
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
     cmark_chunk_set_cstr(&node->as.link.url, url);
     return 1;
   default:
@@ -497,8 +510,8 @@ const char *cmark_node_get_title(cmark_node *node) {
   }
 
   switch (node->type) {
-  case NODE_LINK:
-  case NODE_IMAGE:
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
     return cmark_chunk_to_cstr(&node->as.link.title);
   default:
     break;
@@ -513,8 +526,8 @@ int cmark_node_set_title(cmark_node *node, const char *title) {
   }
 
   switch (node->type) {
-  case NODE_LINK:
-  case NODE_IMAGE:
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
     cmark_chunk_set_cstr(&node->as.link.title, title);
     return 1;
   default:
@@ -524,6 +537,72 @@ int cmark_node_set_title(cmark_node *node, const char *title) {
   return 0;
 }
 
+const char *cmark_node_get_on_enter(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return cmark_chunk_to_cstr(&node->as.custom.on_enter);
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_on_enter(cmark_node *node, const char *on_enter) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    cmark_chunk_set_cstr(&node->as.custom.on_enter, on_enter);
+    return 1;
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+const char *cmark_node_get_on_exit(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return cmark_chunk_to_cstr(&node->as.custom.on_exit);
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_on_exit(cmark_node *node, const char *on_exit) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    cmark_chunk_set_cstr(&node->as.custom.on_exit, on_exit);
+    return 1;
+  default:
+    break;
+  }
+
+  return 0;
+}
+
 int cmark_node_get_start_line(cmark_node *node) {
   if (node == NULL) {
     return 0;