commonmarker 0.17.5 → 0.17.6

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

@@ -13,11 +13,11 @@ cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title);
 CMARK_EXPORT
 void cmark_parse_inlines(cmark_parser *parser,
                          cmark_node *parent,
-                         cmark_reference_map *refmap,
+                         cmark_map *refmap,
                          int options);
 
 bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
-                                       cmark_reference_map *refmap);
+                                       cmark_map *refmap);
 
 void cmark_inlines_add_special_character(unsigned char c, bool emphasis);
 void cmark_inlines_remove_special_character(unsigned char c, bool emphasis);

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

@@ -444,6 +444,11 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     }
     break;
 
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
+    // TODO
+    break;
+
   default:
     assert(false);
     break;

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

@@ -1,6 +1,6 @@
 prefix=@CMAKE_INSTALL_PREFIX@
 exec_prefix=@CMAKE_INSTALL_PREFIX@
-libdir=@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@
+libdir=@CMAKE_INSTALL_PREFIX@/@libdir@
 includedir=@CMAKE_INSTALL_PREFIX@/include
 
 Name: libcmark-gfm

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

@@ -41,6 +41,7 @@ void print_usage() {
   printf("  --smart          Use smart punctuation\n");
   printf("  --validate-utf8  Replace UTF-8 invalid sequences with U+FFFD\n");
   printf("  --github-pre-lang Use GitHub-style <pre lang> for code blocks\n");
+  printf("  --footnotes      Parse footnotes\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");
@@ -138,6 +139,8 @@ int main(int argc, char *argv[]) {
       options |= CMARK_OPT_SMART;
     } else if (strcmp(argv[i], "--github-pre-lang") == 0) {
       options |= CMARK_OPT_GITHUB_PRE_LANG;
+    } else if (strcmp(argv[i], "--footnotes") == 0) {
+      options |= CMARK_OPT_FOOTNOTES;
     } else if (strcmp(argv[i], "--safe") == 0) {
       options |= CMARK_OPT_SAFE;
     } else if (strcmp(argv[i], "--validate-utf8") == 0) {

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

@@ -256,6 +256,11 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     }
     break;
 
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
+    // TODO
+    break;
+
   default:
     assert(false);
     break;

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

@@ -0,0 +1,122 @@
+#include "map.h"
+#include "utf8.h"
+#include "parser.h"
+
+// normalize map label:  collapse internal whitespace to single space,
+// remove leading/trailing whitespace, case fold
+// Return NULL if the label is actually empty (i.e. composed solely from
+// whitespace)
+unsigned char *normalize_map_label(cmark_mem *mem, cmark_chunk *ref) {
+  cmark_strbuf normalized = CMARK_BUF_INIT(mem);
+  unsigned char *result;
+
+  if (ref == NULL)
+    return NULL;
+
+  if (ref->len == 0)
+    return NULL;
+
+  cmark_utf8proc_case_fold(&normalized, ref->data, ref->len);
+  cmark_strbuf_trim(&normalized);
+  cmark_strbuf_normalize_whitespace(&normalized);
+
+  result = cmark_strbuf_detach(&normalized);
+  assert(result);
+
+  if (result[0] == '\0') {
+    mem->free(result);
+    return NULL;
+  }
+
+  return result;
+}
+
+static int
+labelcmp(const unsigned char *a, const unsigned char *b) {
+  return strcmp((const char *)a, (const char *)b);
+}
+
+static int
+refcmp(const void *p1, const void *p2) {
+  cmark_map_entry *r1 = *(cmark_map_entry **)p1;
+  cmark_map_entry *r2 = *(cmark_map_entry **)p2;
+  int res = labelcmp(r1->label, r2->label);
+  return res ? res : ((int)r1->age - (int)r2->age);
+}
+
+static int
+refsearch(const void *label, const void *p2) {
+  cmark_map_entry *ref = *(cmark_map_entry **)p2;
+  return labelcmp((const unsigned char *)label, ref->label);
+}
+
+static void sort_map(cmark_map *map) {
+  unsigned int i = 0, last = 0, size = map->size;
+  cmark_map_entry *r = map->refs, **sorted = NULL;
+
+  sorted = (cmark_map_entry **)map->mem->calloc(size, sizeof(cmark_map_entry *));
+  while (r) {
+    sorted[i++] = r;
+    r = r->next;
+  }
+
+  qsort(sorted, size, sizeof(cmark_map_entry *), refcmp);
+
+  for (i = 1; i < size; i++) {
+    if (labelcmp(sorted[i]->label, sorted[last]->label) != 0)
+      sorted[++last] = sorted[i];
+  }
+
+  map->sorted = sorted;
+  map->size = last + 1;
+}
+
+cmark_map_entry *cmark_map_lookup(cmark_map *map, cmark_chunk *label) {
+  cmark_map_entry **ref = NULL;
+  unsigned char *norm;
+
+  if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH)
+    return NULL;
+
+  if (map == NULL || !map->size)
+    return NULL;
+
+  norm = normalize_map_label(map->mem, label);
+  if (norm == NULL)
+    return NULL;
+
+  if (!map->sorted)
+    sort_map(map);
+
+  ref = (cmark_map_entry **)bsearch(norm, map->sorted, map->size, sizeof(cmark_map_entry *), refsearch);
+  map->mem->free(norm);
+
+  if (!ref)
+    return NULL;
+
+  return ref[0];
+}
+
+void cmark_map_free(cmark_map *map) {
+  cmark_map_entry *ref;
+
+  if (map == NULL)
+    return;
+
+  ref = map->refs;
+  while (ref) {
+    cmark_map_entry *next = ref->next;
+    map->free(map, ref);
+    ref = next;
+  }
+
+  map->mem->free(map->sorted);
+  map->mem->free(map);
+}
+
+cmark_map *cmark_map_new(cmark_mem *mem, cmark_map_free_f free) {
+  cmark_map *map = (cmark_map *)mem->calloc(1, sizeof(cmark_map));
+  map->mem = mem;
+  map->free = free;
+  return map;
+}

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

@@ -0,0 +1,42 @@
+#ifndef CMARK_MAP_H
+#define CMARK_MAP_H
+
+#include "memory.h"
+#include "chunk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct cmark_map_entry {
+  struct cmark_map_entry *next;
+  unsigned char *label;
+  unsigned int age;
+};
+
+typedef struct cmark_map_entry cmark_map_entry;
+
+struct cmark_map;
+
+typedef void (*cmark_map_free_f)(struct cmark_map *, cmark_map_entry *);
+
+struct cmark_map {
+  cmark_mem *mem;
+  cmark_map_entry *refs;
+  cmark_map_entry **sorted;
+  unsigned int size;
+  cmark_map_free_f free;
+};
+
+typedef struct cmark_map cmark_map;
+
+unsigned char *normalize_map_label(cmark_mem *mem, cmark_chunk *ref);
+cmark_map *cmark_map_new(cmark_mem *mem, cmark_map_free_f free);
+void cmark_map_free(cmark_map *map);
+cmark_map_entry *cmark_map_lookup(cmark_map *map, cmark_chunk *label);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -21,6 +21,7 @@ bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type) {
   switch (node->type) {
   case CMARK_NODE_DOCUMENT:
   case CMARK_NODE_BLOCK_QUOTE:
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
   case CMARK_NODE_ITEM:
     return CMARK_NODE_TYPE_BLOCK_P(child_type) && child_type != CMARK_NODE_ITEM;
 
@@ -108,6 +109,8 @@ static void free_node_as(cmark_node *node) {
     case CMARK_NODE_HTML_INLINE:
     case CMARK_NODE_CODE:
     case CMARK_NODE_HTML_BLOCK:
+    case CMARK_NODE_FOOTNOTE_REFERENCE:
+    case CMARK_NODE_FOOTNOTE_DEFINITION:
     cmark_chunk_free(NODE_MEM(node), &node->as.literal);
       break;
     case CMARK_NODE_LINK:
@@ -319,6 +322,7 @@ const char *cmark_node_get_literal(cmark_node *node) {
   case CMARK_NODE_TEXT:
   case CMARK_NODE_HTML_INLINE:
   case CMARK_NODE_CODE:
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
     return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.literal);
 
   case CMARK_NODE_CODE_BLOCK:
@@ -341,6 +345,7 @@ int cmark_node_set_literal(cmark_node *node, const char *content) {
   case CMARK_NODE_TEXT:
   case CMARK_NODE_HTML_INLINE:
   case CMARK_NODE_CODE:
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
     cmark_chunk_set_cstr(NODE_MEM(node), &node->as.literal, content);
     return 1;
 

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

@@ -15,7 +15,7 @@ extern "C" {
 struct cmark_parser {
   struct cmark_mem *mem;
   /* A hashtable of urls in the current document for cross-references */
-  struct cmark_reference_map *refmap;
+  struct cmark_map *refmap;
   /* The root node of the parser, always a CMARK_NODE_DOCUMENT */
   struct cmark_node *root;
   /* The last open block after a line is fully processed */

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

@@ -1,5 +1,6 @@
 #include "node.h"
 #include "syntax_extension.h"
+#include "render.h"
 
 #define OUT(s, wrap, escaping) renderer->out(renderer, node, s, wrap, escaping)
 #define LIT(s) renderer->out(renderer, node, s, false, LITERAL)

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

@@ -1,53 +1,24 @@
 #include "cmark.h"
-#include "utf8.h"
 #include "parser.h"
 #include "references.h"
 #include "inlines.h"
 #include "chunk.h"
 
-static void reference_free(cmark_reference_map *map, cmark_reference *ref) {
+static void reference_free(cmark_map *map, cmark_map_entry *_ref) {
+  cmark_reference *ref = (cmark_reference *)_ref;
   cmark_mem *mem = map->mem;
   if (ref != NULL) {
-    mem->free(ref->label);
+    mem->free(ref->entry.label);
     cmark_chunk_free(mem, &ref->url);
     cmark_chunk_free(mem, &ref->title);
     mem->free(ref);
   }
 }
 
-// normalize reference:  collapse internal whitespace to single space,
-// remove leading/trailing whitespace, case fold
-// Return NULL if the reference name is actually empty (i.e. composed
-// solely from whitespace)
-static unsigned char *normalize_reference(cmark_mem *mem, cmark_chunk *ref) {
-  cmark_strbuf normalized = CMARK_BUF_INIT(mem);
-  unsigned char *result;
-
-  if (ref == NULL)
-    return NULL;
-
-  if (ref->len == 0)
-    return NULL;
-
-  cmark_utf8proc_case_fold(&normalized, ref->data, ref->len);
-  cmark_strbuf_trim(&normalized);
-  cmark_strbuf_normalize_whitespace(&normalized);
-
-  result = cmark_strbuf_detach(&normalized);
-  assert(result);
-
-  if (result[0] == '\0') {
-    mem->free(result);
-    return NULL;
-  }
-
-  return result;
-}
-
-void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label,
+void cmark_reference_create(cmark_map *map, cmark_chunk *label,
                             cmark_chunk *url, cmark_chunk *title) {
   cmark_reference *ref;
-  unsigned char *reflabel = normalize_reference(map->mem, label);
+  unsigned char *reflabel = normalize_map_label(map->mem, label);
 
   /* empty reference name, or composed from only whitespace */
   if (reflabel == NULL)
@@ -56,101 +27,16 @@ void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label,
   assert(map->sorted == NULL);
 
   ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref));
-  ref->label = reflabel;
+  ref->entry.label = reflabel;
   ref->url = cmark_clean_url(map->mem, url);
   ref->title = cmark_clean_title(map->mem, title);
-  ref->age = map->size;
-  ref->next = map->refs;
+  ref->entry.age = map->size;
+  ref->entry.next = map->refs;
 
-  map->refs = ref;
+  map->refs = (cmark_map_entry *)ref;
   map->size++;
 }
 
-static int
-labelcmp(const unsigned char *a, const unsigned char *b) {
-  return strcmp((const char *)a, (const char *)b);
-}
-
-static int
-refcmp(const void *p1, const void *p2) {
-  cmark_reference *r1 = *(cmark_reference **)p1;
-  cmark_reference *r2 = *(cmark_reference **)p2;
-  int res = labelcmp(r1->label, r2->label);
-  return res ? res : ((int)r1->age - (int)r2->age);
-}
-
-static int
-refsearch(const void *label, const void *p2) {
-  cmark_reference *ref = *(cmark_reference **)p2;
-  return labelcmp((const unsigned char *)label, ref->label);
-}
-
-static void sort_references(cmark_reference_map *map) {
-  unsigned int i = 0, last = 0, size = map->size;
-  cmark_reference *r = map->refs, **sorted = NULL;
-
-  sorted = (cmark_reference **)map->mem->calloc(size, sizeof(cmark_reference *));
-  while (r) {
-    sorted[i++] = r;
-    r = r->next;
-  }
-
-  qsort(sorted, size, sizeof(cmark_reference *), refcmp);
-
-  for (i = 1; i < size; i++) {
-    if (labelcmp(sorted[i]->label, sorted[last]->label) != 0)
-      sorted[++last] = sorted[i];
-  }
-
-  map->sorted = sorted;
-  map->size = last + 1;
-}
-
-// Returns reference if refmap contains a reference with matching
-// label, otherwise NULL.
-cmark_reference *cmark_reference_lookup(cmark_reference_map *map,
-                                        cmark_chunk *label) {
-  cmark_reference **ref = NULL;
-  unsigned char *norm;
-
-  if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH)
-    return NULL;
-
-  if (map == NULL || !map->size)
-    return NULL;
-
-  norm = normalize_reference(map->mem, label);
-  if (norm == NULL)
-    return NULL;
-
-  if (!map->sorted)
-    sort_references(map);
-
-  ref = (cmark_reference **)bsearch(norm, map->sorted, map->size, sizeof(cmark_reference *), refsearch);
-  map->mem->free(norm);
-  return ref ? ref[0] : NULL;
-}
-
-void cmark_reference_map_free(cmark_reference_map *map) {
-  cmark_reference *ref;
-
-  if (map == NULL)
-    return;
-
-  ref = map->refs;
-  while (ref) {
-    cmark_reference *next = ref->next;
-    reference_free(map, ref);
-    ref = next;
-  }
-
-  map->mem->free(map->sorted);
-  map->mem->free(map);
-}
-
-cmark_reference_map *cmark_reference_map_new(cmark_mem *mem) {
-  cmark_reference_map *map =
-      (cmark_reference_map *)mem->calloc(1, sizeof(cmark_reference_map));
-  map->mem = mem;
-  return map;
+cmark_map *cmark_reference_map_new(cmark_mem *mem) {
+  return cmark_map_new(mem, reference_free);
 }