markly 0.1.0

data/ext/markly/ext_scanners.h

@@ -0,0 +1,24 @@
+#include "chunk.h"
+#include "cmark-gfm.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+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);
+bufsize_t _scan_tasklist(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)
+#define scan_tasklist(c, l, n) _ext_scan_at(&_scan_tasklist, c, l, n)
+
+#ifdef __cplusplus
+}
+#endif

data/ext/markly/extconf.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+$CFLAGS << ' -std=c99'
+
+create_makefile('markly/markly')

data/ext/markly/footnotes.c

@@ -0,0 +1,40 @@
+#include "cmark-gfm.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/markly/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/markly/houdini.h

@@ -0,0 +1,57 @@
+#ifndef CMARK_HOUDINI_H
+#define CMARK_HOUDINI_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include "config.h"
+#include "buffer.h"
+
+#ifdef HAVE___BUILTIN_EXPECT
+#define likely(x) __builtin_expect((x), 1)
+#define unlikely(x) __builtin_expect((x), 0)
+#else
+#define likely(x) (x)
+#define unlikely(x) (x)
+#endif
+
+#ifdef HOUDINI_USE_LOCALE
+#define _isxdigit(c) isxdigit(c)
+#define _isdigit(c) isdigit(c)
+#else
+/*
+ * Helper _isdigit methods -- do not trust the current locale
+ * */
+#define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL)
+#define _isdigit(c) ((c) >= '0' && (c) <= '9')
+#endif
+
+#define HOUDINI_ESCAPED_SIZE(x) (((x)*12) / 10)
+#define HOUDINI_UNESCAPED_SIZE(x) (x)
+
+CMARK_GFM_EXPORT
+bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src,
+                                      bufsize_t size);
+CMARK_GFM_EXPORT
+int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src,
+                               bufsize_t size);
+CMARK_GFM_EXPORT
+int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src,
+                                bufsize_t size, int secure);
+CMARK_GFM_EXPORT
+int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src,
+                                 bufsize_t size);
+CMARK_GFM_EXPORT
+void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src,
+                                    bufsize_t size);
+CMARK_GFM_EXPORT
+int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src,
+                               bufsize_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/markly/houdini_href_e.c

@@ -0,0 +1,100 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+/*
+ * The following characters will not be escaped:
+ *
+ *		-_.+!*'(),%#@?=;:/,+&$~ alphanum
+ *
+ * Note that this character set is the addition of:
+ *
+ *	- The characters which are safe to be in an URL
+ *	- The characters which are *not* safe to be in
+ *	an URL because they are RESERVED characters.
+ *
+ * We assume (lazily) that any RESERVED char that
+ * appears inside an URL is actually meant to
+ * have its native function (i.e. as an URL
+ * component/separator) and hence needs no escaping.
+ *
+ * There are two exceptions: the chacters & (amp)
+ * and ' (single quote) do not appear in the table.
+ * They are meant to appear in the URL as components,
+ * yet they require special HTML-entity escaping
+ * to generate valid HTML markup.
+ *
+ * All other characters will be escaped to %XX.
+ *
+ */
+static const char HREF_SAFE[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) {
+  static const uint8_t hex_chars[] = "0123456789ABCDEF";
+  bufsize_t i = 0, org;
+  uint8_t hex_str[3];
+
+  hex_str[0] = '%';
+
+  while (i < size) {
+    org = i;
+    while (i < size && HREF_SAFE[src[i]] != 0)
+      i++;
+
+    if (likely(i > org))
+      cmark_strbuf_put(ob, src + org, i - org);
+
+    /* escaping */
+    if (i >= size)
+      break;
+
+    switch (src[i]) {
+    /* amp appears all the time in URLs, but needs
+     * HTML-entity escaping to be inside an href */
+    case '&':
+      cmark_strbuf_puts(ob, "&amp;");
+      break;
+
+    /* the single quote is a valid URL character
+     * according to the standard; it needs HTML
+     * entity escaping too */
+    case '\'':
+      cmark_strbuf_puts(ob, "&#x27;");
+      break;
+
+/* the space can be escaped to %20 or a plus
+ * sign. we're going with the generic escape
+ * for now. the plus thing is more commonly seen
+ * when building GET strings */
+#if 0
+		case ' ':
+			cmark_strbuf_putc(ob, '+');
+			break;
+#endif
+
+    /* every other character goes with a %XX escaping */
+    default:
+      hex_str[1] = hex_chars[(src[i] >> 4) & 0xF];
+      hex_str[2] = hex_chars[src[i] & 0xF];
+      cmark_strbuf_put(ob, hex_str, 3);
+    }
+
+    i++;
+  }
+
+  return 1;
+}

data/ext/markly/houdini_html_e.c

@@ -0,0 +1,66 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+/**
+ * According to the OWASP rules:
+ *
+ * & --> &amp;
+ * < --> &lt;
+ * > --> &gt;
+ * " --> &quot;
+ * ' --> &#x27;     &apos; is not recommended
+ * / --> &#x2F;     forward slash is included as it helps end an HTML entity
+ *
+ */
+static const char HTML_ESCAPE_TABLE[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 4,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const char *HTML_ESCAPES[] = {"",      "&quot;", "&amp;", "&#39;",
+                                     "&#47;", "&lt;",   "&gt;"};
+
+int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, bufsize_t size,
+                         int secure) {
+  bufsize_t i = 0, org, esc = 0;
+
+  while (i < size) {
+    org = i;
+    while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0)
+      i++;
+
+    if (i > org)
+      cmark_strbuf_put(ob, src + org, i - org);
+
+    /* escaping */
+    if (unlikely(i >= size))
+      break;
+
+    /* The forward slash and single quote are only escaped in secure mode */
+    if ((src[i] == '/' || src[i] == '\'') && !secure) {
+      cmark_strbuf_putc(ob, src[i]);
+    } else {
+      cmark_strbuf_puts(ob, HTML_ESCAPES[esc]);
+    }
+
+    i++;
+  }
+
+  return 1;
+}
+
+int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) {
+  return houdini_escape_html0(ob, src, size, 1);
+}

data/ext/markly/houdini_html_u.c

@@ -0,0 +1,149 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "buffer.h"
+#include "houdini.h"
+#include "utf8.h"
+#include "entities.inc"
+
+/* Binary tree lookup code for entities added by JGM */
+
+static const unsigned char *S_lookup(int i, int low, int hi,
+                                     const unsigned char *s, int len) {
+  int j;
+  int cmp =
+      strncmp((const char *)s, (const char *)cmark_entities[i].entity, len);
+  if (cmp == 0 && cmark_entities[i].entity[len] == 0) {
+    return (const unsigned char *)cmark_entities[i].bytes;
+  } else if (cmp <= 0 && i > low) {
+    j = i - ((i - low) / 2);
+    if (j == i)
+      j -= 1;
+    return S_lookup(j, low, i - 1, s, len);
+  } else if (cmp > 0 && i < hi) {
+    j = i + ((hi - i) / 2);
+    if (j == i)
+      j += 1;
+    return S_lookup(j, i + 1, hi, s, len);
+  } else {
+    return NULL;
+  }
+}
+
+static const unsigned char *S_lookup_entity(const unsigned char *s, int len) {
+  return S_lookup(CMARK_NUM_ENTITIES / 2, 0, CMARK_NUM_ENTITIES - 1, s, len);
+}
+
+bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src,
+                               bufsize_t size) {
+  bufsize_t i = 0;
+
+  if (size >= 3 && src[0] == '#') {
+    int codepoint = 0;
+    int num_digits = 0;
+
+    if (_isdigit(src[1])) {
+      for (i = 1; i < size && _isdigit(src[i]); ++i) {
+        codepoint = (codepoint * 10) + (src[i] - '0');
+
+        if (codepoint >= 0x110000) {
+          // Keep counting digits but
+          // avoid integer overflow.
+          codepoint = 0x110000;
+        }
+      }
+
+      num_digits = i - 1;
+    }
+
+    else if (src[1] == 'x' || src[1] == 'X') {
+      for (i = 2; i < size && _isxdigit(src[i]); ++i) {
+        codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9);
+
+        if (codepoint >= 0x110000) {
+          // Keep counting digits but
+          // avoid integer overflow.
+          codepoint = 0x110000;
+        }
+      }
+
+      num_digits = i - 2;
+    }
+
+    if (num_digits >= 1 && num_digits <= 8 && i < size && src[i] == ';') {
+      if (codepoint == 0 || (codepoint >= 0xD800 && codepoint < 0xE000) ||
+          codepoint >= 0x110000) {
+        codepoint = 0xFFFD;
+      }
+      cmark_utf8proc_encode_char(codepoint, ob);
+      return i + 1;
+    }
+  }
+
+  else {
+    if (size > CMARK_ENTITY_MAX_LENGTH)
+      size = CMARK_ENTITY_MAX_LENGTH;
+
+    for (i = CMARK_ENTITY_MIN_LENGTH; i < size; ++i) {
+      if (src[i] == ' ')
+        break;
+
+      if (src[i] == ';') {
+        const unsigned char *entity = S_lookup_entity(src, i);
+
+        if (entity != NULL) {
+          cmark_strbuf_puts(ob, (const char *)entity);
+          return i + 1;
+        }
+
+        break;
+      }
+    }
+  }
+
+  return 0;
+}
+
+int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src,
+                          bufsize_t size) {
+  bufsize_t i = 0, org, ent;
+
+  while (i < size) {
+    org = i;
+    while (i < size && src[i] != '&')
+      i++;
+
+    if (likely(i > org)) {
+      if (unlikely(org == 0)) {
+        if (i >= size)
+          return 0;
+
+        cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size));
+      }
+
+      cmark_strbuf_put(ob, src + org, i - org);
+    }
+
+    /* escaping */
+    if (i >= size)
+      break;
+
+    i++;
+
+    ent = houdini_unescape_ent(ob, src + i, size - i);
+    i += ent;
+
+    /* not really an entity */
+    if (ent == 0)
+      cmark_strbuf_putc(ob, '&');
+  }
+
+  return 1;
+}
+
+void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src,
+                             bufsize_t size) {
+  if (!houdini_unescape_html(ob, src, size))
+    cmark_strbuf_put(ob, src, size);
+}