commonmarker 0.17.5 → 0.17.6

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

@@ -13,8 +13,6 @@
 extern "C" {
 #endif
 
-typedef int32_t bufsize_t;
-
 typedef struct {
   cmark_mem *mem;
   unsigned char *ptr;

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

@@ -12,7 +12,7 @@
 #define CMARK_CHUNK_EMPTY                                                      \
   { NULL, 0, 0 }
 
-typedef struct {
+typedef struct cmark_chunk {
   unsigned char *data;
   bufsize_t len;
   bufsize_t alloc; // also implies a NULL-terminated string

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

@@ -7,8 +7,8 @@
 #include "cmark.h"
 #include "buffer.h"
 
-cmark_node_type CMARK_NODE_LAST_BLOCK = CMARK_NODE_THEMATIC_BREAK;
-cmark_node_type CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE;
+cmark_node_type CMARK_NODE_LAST_BLOCK = CMARK_NODE_FOOTNOTE_DEFINITION;
+cmark_node_type CMARK_NODE_LAST_INLINE = CMARK_NODE_FOOTNOTE_REFERENCE;
 
 int cmark_version() { return CMARK_VERSION; }
 

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

@@ -2,6 +2,7 @@
 #define CMARK_CMARK_H
 
 #include <stdio.h>
+#include <stdint.h>
 #include "cmark_export.h"
 #include "cmark_version.h"
 
@@ -51,6 +52,7 @@ typedef enum {
   CMARK_NODE_PARAGRAPH      = CMARK_NODE_TYPE_BLOCK | 0x0008,
   CMARK_NODE_HEADING        = CMARK_NODE_TYPE_BLOCK | 0x0009,
   CMARK_NODE_THEMATIC_BREAK = CMARK_NODE_TYPE_BLOCK | 0x000a,
+  CMARK_NODE_FOOTNOTE_DEFINITION = CMARK_NODE_TYPE_BLOCK | 0x000b,
 
   /* Inline */
   CMARK_NODE_TEXT          = CMARK_NODE_TYPE_INLINE | 0x0001,
@@ -63,6 +65,7 @@ typedef enum {
   CMARK_NODE_STRONG        = CMARK_NODE_TYPE_INLINE | 0x0008,
   CMARK_NODE_LINK          = CMARK_NODE_TYPE_INLINE | 0x0009,
   CMARK_NODE_IMAGE         = CMARK_NODE_TYPE_INLINE | 0x000a,
+  CMARK_NODE_FOOTNOTE_REFERENCE = CMARK_NODE_TYPE_INLINE | 0x000b,
 } cmark_node_type;
 
 extern cmark_node_type CMARK_NODE_LAST_BLOCK;
@@ -717,6 +720,10 @@ char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmar
  */
 #define CMARK_OPT_LIBERAL_HTML_TAG (1 << 12)
 
+/** Parse footnotes.
+ */
+#define CMARK_OPT_FOOTNOTES (1 << 13)
+
 /**
  * ## Version information
  */
@@ -773,6 +780,8 @@ const char *cmark_version_string(void);
 #define PAREN_DELIM CMARK_PAREN_DELIM
 #endif
 
+typedef int32_t bufsize_t;
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -6,8 +6,10 @@ extern "C" {
 #endif
 
 #include <cmark.h>
-#include <render.h>
-#include <buffer.h>
+
+struct cmark_renderer;
+struct cmark_html_renderer;
+struct cmark_chunk;
 
 /**
  * ## Extension Support
@@ -227,7 +229,7 @@ typedef int (*cmark_contains_inlines_func) (cmark_syntax_extension *extension,
                                             cmark_node *node);
 
 typedef void (*cmark_common_render_func) (cmark_syntax_extension *extension,
-                                          cmark_renderer *renderer,
+                                          struct cmark_renderer *renderer,
                                           cmark_node *node,
                                           cmark_event_type ev_type,
                                           int options);
@@ -237,7 +239,7 @@ typedef int (*cmark_commonmark_escape_func) (cmark_syntax_extension *extension,
                                               int c);
 
 typedef void (*cmark_html_render_func) (cmark_syntax_extension *extension,
-                                        cmark_html_renderer *renderer,
+                                        struct cmark_html_renderer *renderer,
                                         cmark_node *node,
                                         cmark_event_type ev_type,
                                         int options);
@@ -270,7 +272,7 @@ CMARK_EXPORT
 cmark_node_type cmark_syntax_extension_add_node(int is_inline);
 
 CMARK_EXPORT
-void cmark_syntax_extension_set_emphasis(cmark_syntax_extension *extension, bool emphasis);
+void cmark_syntax_extension_set_emphasis(cmark_syntax_extension *extension, int emphasis);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
@@ -614,7 +616,7 @@ void cmark_inline_parser_set_offset(cmark_inline_parser *parser, int offset);
  * Use cmark_inline_parser_get_offset to get our current position in the chunk.
  */
 CMARK_EXPORT
-cmark_chunk *cmark_inline_parser_get_chunk(cmark_inline_parser *parser);
+struct cmark_chunk *cmark_inline_parser_get_chunk(cmark_inline_parser *parser);
 
 /** Returns 1 if the inline parser is currently in a bracket; pass 1 for 'image'
  * if you want to know about an image-type bracket, 0 for link-type. */
@@ -699,7 +701,7 @@ int cmark_inline_parser_scan_delimiters(cmark_inline_parser *parser,
                                   int *punct_after);
 
 CMARK_EXPORT
-void cmark_manage_extensions_special_characters(cmark_parser *parser, bool add);
+void cmark_manage_extensions_special_characters(cmark_parser *parser, int add);
 
 CMARK_EXPORT
 cmark_llist *cmark_parser_get_syntax_extensions(cmark_parser *parser);

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

@@ -463,6 +463,29 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     }
     break;
 
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
+    if (entering) {
+      LIT("[^");
+      OUT(cmark_chunk_to_cstr(renderer->mem, &node->as.literal), false, LITERAL);
+      LIT("]");
+    }
+    break;
+
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
+    if (entering) {
+      renderer->footnote_ix += 1;
+      LIT("[^");
+      char n[32];
+      snprintf(n, sizeof(n), "%d", renderer->footnote_ix);
+      OUT(n, false, LITERAL);
+      LIT("]:\n");
+
+      cmark_strbuf_puts(renderer->prefix, "    ");
+    } else {
+      cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 4);
+    }
+    break;
+
   default:
     assert(false);
     break;

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

@@ -0,0 +1,40 @@
+#include "cmark.h"
+#include "parser.h"
+#include "footnotes.h"
+#include "inlines.h"
+#include "chunk.h"
+
+static void footnote_free(cmark_map *map, cmark_map_entry *_ref) {
+  cmark_footnote *ref = (cmark_footnote *)_ref;
+  cmark_mem *mem = map->mem;
+  if (ref != NULL) {
+    mem->free(ref->entry.label);
+    if (ref->node)
+      cmark_node_free(ref->node);
+    mem->free(ref);
+  }
+}
+
+void cmark_footnote_create(cmark_map *map, cmark_node *node) {
+  cmark_footnote *ref;
+  unsigned char *reflabel = normalize_map_label(map->mem, &node->as.literal);
+
+  /* empty footnote name, or composed from only whitespace */
+  if (reflabel == NULL)
+    return;
+
+  assert(map->sorted == NULL);
+
+  ref = (cmark_footnote *)map->mem->calloc(1, sizeof(*ref));
+  ref->entry.label = reflabel;
+  ref->node = node;
+  ref->entry.age = map->size;
+  ref->entry.next = map->refs;
+
+  map->refs = (cmark_map_entry *)ref;
+  map->size++;
+}
+
+cmark_map *cmark_footnote_map_new(cmark_mem *mem) {
+  return cmark_map_new(mem, footnote_free);
+}

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

@@ -0,0 +1,25 @@
+#ifndef CMARK_FOOTNOTES_H
+#define CMARK_FOOTNOTES_H
+
+#include "map.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct cmark_footnote {
+  cmark_map_entry entry;
+  cmark_node *node;
+  unsigned int ix;
+};
+
+typedef struct cmark_footnote cmark_footnote;
+
+void cmark_footnote_create(cmark_map *map, cmark_node *node);
+cmark_map *cmark_footnote_map_new(cmark_mem *mem);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -9,6 +9,7 @@
 #include "scanners.h"
 #include "syntax_extension.h"
 #include "html.h"
+#include "render.h"
 
 // Functions to convert cmark_nodes to HTML strings.
 
@@ -58,6 +59,20 @@ static void filter_html_block(cmark_html_renderer *renderer, uint8_t *data, size
     cmark_strbuf_put(html, data, (bufsize_t)len);
 }
 
+static bool S_put_footnote_backref(cmark_html_renderer *renderer, cmark_strbuf *html) {
+  if (renderer->written_footnote_ix >= renderer->footnote_ix)
+    return false;
+  renderer->written_footnote_ix = renderer->footnote_ix;
+
+  cmark_strbuf_puts(html, "<a href=\"#fnref");
+  char n[32];
+  snprintf(n, sizeof(n), "%d", renderer->footnote_ix);
+  cmark_strbuf_puts(html, n);
+  cmark_strbuf_puts(html, "\" class=\"footnote-backref\">↩</a>");
+
+  return true;
+}
+
 static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
                          cmark_event_type ev_type, int options) {
   cmark_node *parent;
@@ -248,6 +263,10 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
         cmark_html_render_sourcepos(node, html, options);
         cmark_strbuf_putc(html, '>');
       } else {
+        if (parent->type == CMARK_NODE_FOOTNOTE_DEFINITION && node->next == NULL) {
+          cmark_strbuf_putc(html, ' ');
+          S_put_footnote_backref(renderer, html);
+        }
         cmark_strbuf_puts(html, "</p>\n");
       }
     }
@@ -362,6 +381,37 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
     }
     break;
 
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
+    if (entering) {
+      if (renderer->footnote_ix == 0) {
+        cmark_strbuf_puts(html, "<section class=\"footnotes\">\n<ol>\n");
+      }
+      ++renderer->footnote_ix;
+      cmark_strbuf_puts(html, "<li id=\"fn");
+      char n[32];
+      snprintf(n, sizeof(n), "%d", renderer->footnote_ix);
+      cmark_strbuf_puts(html, n);
+      cmark_strbuf_puts(html, "\">\n");
+    } else {
+      if (S_put_footnote_backref(renderer, html)) {
+        cmark_strbuf_putc(html, '\n');
+      }
+      cmark_strbuf_puts(html, "</li>\n");
+    }
+    break;
+
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
+    if (entering) {
+      cmark_strbuf_puts(html, "<sup class=\"footnote-ref\"><a href=\"#fn");
+      cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
+      cmark_strbuf_puts(html, "\" id=\"fnref");
+      cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
+      cmark_strbuf_puts(html, "\">[");
+      cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
+      cmark_strbuf_puts(html, "]</a></sup>");
+    }
+    break;
+
   default:
     assert(false);
     break;
@@ -379,7 +429,7 @@ char *cmark_render_html_with_mem(cmark_node *root, int options, cmark_llist *ext
   cmark_strbuf html = CMARK_BUF_INIT(mem);
   cmark_event_type ev_type;
   cmark_node *cur;
-  cmark_html_renderer renderer = {&html, NULL, NULL, NULL};
+  cmark_html_renderer renderer = {&html, NULL, NULL, 0, 0, NULL};
   cmark_iter *iter = cmark_iter_new(root);
 
   for (; extensions; extensions = extensions->next)
@@ -393,6 +443,11 @@ char *cmark_render_html_with_mem(cmark_node *root, int options, cmark_llist *ext
     cur = cmark_iter_get_node(iter);
     S_render_node(&renderer, cur, ev_type, options);
   }
+
+  if (renderer.footnote_ix) {
+    cmark_strbuf_puts(&html, "</ol>\n</section>\n");
+  }
+
   result = (char *)cmark_strbuf_detach(&html);
 
   cmark_llist_free(mem, renderer.filter_extensions);

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

@@ -50,7 +50,7 @@ typedef struct subject{
   bufsize_t pos;
   int block_offset;
   int column_offset;
-  cmark_reference_map *refmap;
+  cmark_map *refmap;
   delimiter *last_delim;
   bracket *last_bracket;
   bufsize_t backticks[MAXBACKTICKS + 1];
@@ -70,7 +70,7 @@ static delimiter *S_insert_emph(subject *subj, delimiter *opener,
 static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent, int options);
 
 static void subject_from_buf(cmark_mem *mem, int line_number, int block_offset, subject *e,
-                             cmark_chunk *buffer, cmark_reference_map *refmap);
+                             cmark_chunk *buffer, cmark_map *refmap);
 static bufsize_t subject_find_special_char(subject *subj, int options);
 
 // Create an inline with a literal string value.
@@ -157,7 +157,7 @@ static CMARK_INLINE cmark_node *make_autolink(subject *subj,
 }
 
 static void subject_from_buf(cmark_mem *mem, int line_number, int block_offset, subject *e,
-                             cmark_chunk *chunk, cmark_reference_map *refmap) {
+                             cmark_chunk *chunk, cmark_map *refmap) {
   int i;
   e->mem = mem;
   e->input = *chunk;
@@ -793,7 +793,7 @@ cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url) {
     return result;
   }
 
-    houdini_unescape_html_f(&buf, url->data, url->len);
+  houdini_unescape_html_f(&buf, url->data, url->len);
 
   cmark_strbuf_unescape(&buf);
   return cmark_chunk_buf_detach(&buf);
@@ -925,26 +925,26 @@ static bufsize_t manual_scan_link_url_2(cmark_chunk *input, bufsize_t offset,
   bufsize_t i = offset;
   size_t nb_p = 0;
 
-    while (i < input->len) {
-      if (input->data[i] == '\\' &&
-	  i + 1 < input-> len &&
-          cmark_ispunct(input->data[i+1]))
-        i += 2;
-      else if (input->data[i] == '(') {
-        ++nb_p;
-        ++i;
+  while (i < input->len) {
+    if (input->data[i] == '\\' &&
+        i + 1 < input-> len &&
+        cmark_ispunct(input->data[i+1]))
+      i += 2;
+    else if (input->data[i] == '(') {
+      ++nb_p;
+      ++i;
         if (nb_p > 32)
           return -1;
-      } else if (input->data[i] == ')') {
-        if (nb_p == 0)
-          break;
-        --nb_p;
-        ++i;
-      } else if (cmark_isspace(input->data[i]))
+    } else if (input->data[i] == ')') {
+      if (nb_p == 0)
         break;
-      else
-        ++i;
-    }
+      --nb_p;
+      ++i;
+    } else if (cmark_isspace(input->data[i]))
+      break;
+    else
+      ++i;
+  }
 
   if (i >= input->len)
     return -1;
@@ -1076,7 +1076,7 @@ static cmark_node *handle_close_bracket(cmark_parser *parser, subject *subj) {
   }
 
   if (found_label) {
-    ref = cmark_reference_lookup(subj->refmap, &raw_label);
+    ref = (cmark_reference *)cmark_map_lookup(subj->refmap, &raw_label);
     cmark_chunk_free(subj->mem, &raw_label);
   }
 
@@ -1089,7 +1089,28 @@ static cmark_node *handle_close_bracket(cmark_parser *parser, subject *subj) {
   }
 
 noMatch:
-  // If we fall through to here, it means we didn't match a link:
+  // If we fall through to here, it means we didn't match a link.
+  // What if we're a footnote link?
+  if (parser->options & CMARK_OPT_FOOTNOTES &&
+      opener->inl_text->next &&
+      opener->inl_text->next->type == CMARK_NODE_TEXT &&
+      !opener->inl_text->next->next) {
+    cmark_chunk *literal = &opener->inl_text->next->as.literal;
+    if (literal->len > 1 && literal->data[0] == '^') {
+      inl = make_simple(subj->mem, CMARK_NODE_FOOTNOTE_REFERENCE);
+      inl->as.literal = cmark_chunk_dup(literal, 1, literal->len - 1);
+      inl->start_line = inl->end_line = subj->line;
+      inl->start_column = opener->inl_text->start_column;
+      inl->end_column = subj->pos + subj->column_offset + subj->block_offset;
+      cmark_node_insert_before(opener->inl_text, inl);
+      cmark_node_free(opener->inl_text->next);
+      cmark_node_free(opener->inl_text);
+      process_emphasis(parser, subj, opener->previous_delimiter);
+      pop_bracket(subj);
+      return NULL;
+    }
+  }
+
   pop_bracket(subj); // remove this opener from delimiter list
   subj->pos = initial_pos;
   return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("]"));
@@ -1317,7 +1338,7 @@ static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent,
 // Parse inlines from parent's string_content, adding as children of parent.
 void cmark_parse_inlines(cmark_parser *parser,
                          cmark_node *parent,
-                         cmark_reference_map *refmap,
+                         cmark_map *refmap,
                          int options) {
   subject subj;
   cmark_chunk content = {parent->content.ptr, parent->content.size, 0};
@@ -1350,7 +1371,7 @@ static void spnl(subject *subj) {
 // Return 0 if no reference found, otherwise position of subject
 // after reference is parsed.
 bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
-                                       cmark_reference_map *refmap) {
+                                       cmark_map *refmap) {
   subject subj;
 
   cmark_chunk lab;