markly 0.1.0

data/ext/markly/plugin.h

@@ -0,0 +1,34 @@
+#ifndef CMARK_PLUGIN_H
+#define CMARK_PLUGIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
+
+/**
+ * cmark_plugin:
+ *
+ * A plugin structure, which should be filled by plugin's
+ * init functions.
+ */
+struct cmark_plugin {
+  cmark_llist *syntax_extensions;
+};
+
+cmark_llist *
+cmark_plugin_steal_syntax_extensions(cmark_plugin *plugin);
+
+cmark_plugin *
+cmark_plugin_new(void);
+
+void
+cmark_plugin_free(cmark_plugin *plugin);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/markly/references.c

@@ -0,0 +1,42 @@
+#include "cmark-gfm.h"
+#include "parser.h"
+#include "references.h"
+#include "inlines.h"
+#include "chunk.h"
+
+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->entry.label);
+    cmark_chunk_free(mem, &ref->url);
+    cmark_chunk_free(mem, &ref->title);
+    mem->free(ref);
+  }
+}
+
+void cmark_reference_create(cmark_map *map, cmark_chunk *label,
+                            cmark_chunk *url, cmark_chunk *title) {
+  cmark_reference *ref;
+  unsigned char *reflabel = normalize_map_label(map->mem, label);
+
+  /* empty reference name, or composed from only whitespace */
+  if (reflabel == NULL)
+    return;
+
+  assert(map->sorted == NULL);
+
+  ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref));
+  ref->entry.label = reflabel;
+  ref->url = cmark_clean_url(map->mem, url);
+  ref->title = cmark_clean_title(map->mem, title);
+  ref->entry.age = map->size;
+  ref->entry.next = map->refs;
+
+  map->refs = (cmark_map_entry *)ref;
+  map->size++;
+}
+
+cmark_map *cmark_reference_map_new(cmark_mem *mem) {
+  return cmark_map_new(mem, reference_free);
+}

data/ext/markly/references.h

@@ -0,0 +1,26 @@
+#ifndef CMARK_REFERENCES_H
+#define CMARK_REFERENCES_H
+
+#include "map.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct cmark_reference {
+  cmark_map_entry entry;
+  cmark_chunk url;
+  cmark_chunk title;
+};
+
+typedef struct cmark_reference cmark_reference;
+
+void cmark_reference_create(cmark_map *map, cmark_chunk *label,
+                            cmark_chunk *url, cmark_chunk *title);
+cmark_map *cmark_reference_map_new(cmark_mem *mem);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/markly/registry.c

@@ -0,0 +1,63 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "config.h"
+#include "cmark-gfm.h"
+#include "syntax_extension.h"
+#include "registry.h"
+#include "plugin.h"
+
+extern cmark_mem CMARK_DEFAULT_MEM_ALLOCATOR;
+
+static cmark_llist *syntax_extensions = NULL;
+
+void cmark_register_plugin(cmark_plugin_init_func reg_fn) {
+  cmark_plugin *plugin = cmark_plugin_new();
+
+  if (!reg_fn(plugin)) {
+    cmark_plugin_free(plugin);
+    return;
+  }
+
+  cmark_llist *syntax_extensions_list = cmark_plugin_steal_syntax_extensions(plugin),
+              *it;
+
+  for (it = syntax_extensions_list; it; it = it->next) {
+    syntax_extensions = cmark_llist_append(&CMARK_DEFAULT_MEM_ALLOCATOR, syntax_extensions, it->data);
+  }
+
+  cmark_llist_free(&CMARK_DEFAULT_MEM_ALLOCATOR, syntax_extensions_list);
+  cmark_plugin_free(plugin);
+}
+
+void cmark_release_plugins(void) {
+  if (syntax_extensions) {
+    cmark_llist_free_full(
+        &CMARK_DEFAULT_MEM_ALLOCATOR,
+        syntax_extensions,
+        (cmark_free_func) cmark_syntax_extension_free);
+    syntax_extensions = NULL;
+  }
+}
+
+cmark_llist *cmark_list_syntax_extensions(cmark_mem *mem) {
+  cmark_llist *it;
+  cmark_llist *res = NULL;
+
+  for (it = syntax_extensions; it; it = it->next) {
+    res = cmark_llist_append(mem, res, it->data);
+  }
+  return res;
+}
+
+cmark_syntax_extension *cmark_find_syntax_extension(const char *name) {
+  cmark_llist *tmp;
+
+  for (tmp = syntax_extensions; tmp; tmp = tmp->next) {
+    cmark_syntax_extension *ext = (cmark_syntax_extension *) tmp->data;
+    if (!strcmp(ext->name, name))
+      return ext;
+  }
+  return NULL;
+}

data/ext/markly/registry.h

@@ -0,0 +1,24 @@
+#ifndef CMARK_REGISTRY_H
+#define CMARK_REGISTRY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cmark-gfm.h"
+#include "plugin.h"
+
+CMARK_GFM_EXPORT
+void cmark_register_plugin(cmark_plugin_init_func reg_fn);
+
+CMARK_GFM_EXPORT
+void cmark_release_plugins(void);
+
+CMARK_GFM_EXPORT
+cmark_llist *cmark_list_syntax_extensions(cmark_mem *mem);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/markly/render.c

@@ -0,0 +1,205 @@
+#include <stdlib.h>
+#include "buffer.h"
+#include "chunk.h"
+#include "cmark-gfm.h"
+#include "utf8.h"
+#include "render.h"
+#include "node.h"
+#include "syntax_extension.h"
+
+static CMARK_INLINE void S_cr(cmark_renderer *renderer) {
+  if (renderer->need_cr < 1) {
+    renderer->need_cr = 1;
+  }
+}
+
+static CMARK_INLINE void S_blankline(cmark_renderer *renderer) {
+  if (renderer->need_cr < 2) {
+    renderer->need_cr = 2;
+  }
+}
+
+static void S_out(cmark_renderer *renderer, cmark_node *node,
+                  const char *source, bool wrap,
+                  cmark_escaping escape) {
+  int length = (int)strlen(source);
+  unsigned char nextc;
+  int32_t c;
+  int i = 0;
+  int last_nonspace;
+  int len;
+  cmark_chunk remainder = cmark_chunk_literal("");
+  int k = renderer->buffer->size - 1;
+
+  cmark_syntax_extension *ext = NULL;
+  cmark_node *n = node;
+  while (n && !ext) {
+    ext = n->extension;
+    if (!ext)
+      n = n->parent;
+  }
+  if (ext && !ext->commonmark_escape_func)
+    ext = NULL;
+
+  wrap = wrap && !renderer->no_linebreaks;
+
+  if (renderer->in_tight_list_item && renderer->need_cr > 1) {
+    renderer->need_cr = 1;
+  }
+  while (renderer->need_cr) {
+    if (k < 0 || renderer->buffer->ptr[k] == '\n') {
+      k -= 1;
+    } else {
+      cmark_strbuf_putc(renderer->buffer, '\n');
+      if (renderer->need_cr > 1) {
+        cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+                         renderer->prefix->size);
+      }
+    }
+    renderer->column = 0;
+    renderer->last_breakable = 0;
+    renderer->begin_line = true;
+    renderer->begin_content = true;
+    renderer->need_cr -= 1;
+  }
+
+  while (i < length) {
+    if (renderer->begin_line) {
+      cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+                       renderer->prefix->size);
+      // note: this assumes prefix is ascii:
+      renderer->column = renderer->prefix->size;
+    }
+
+    len = cmark_utf8proc_iterate((const uint8_t *)source + i, length - i, &c);
+    if (len == -1) { // error condition
+      return;        // return without rendering rest of string
+    }
+
+    if (ext && ext->commonmark_escape_func(ext, node, c))
+      cmark_strbuf_putc(renderer->buffer, '\\');
+
+    nextc = source[i + len];
+    if (c == 32 && wrap) {
+      if (!renderer->begin_line) {
+        last_nonspace = renderer->buffer->size;
+        cmark_strbuf_putc(renderer->buffer, ' ');
+        renderer->column += 1;
+        renderer->begin_line = false;
+        renderer->begin_content = false;
+        // skip following spaces
+        while (source[i + 1] == ' ') {
+          i++;
+        }
+        // We don't allow breaks that make a digit the first character
+        // because this causes problems with commonmark output.
+        if (!cmark_isdigit(source[i + 1])) {
+          renderer->last_breakable = last_nonspace;
+        }
+      }
+
+    } else if (escape == LITERAL) {
+      if (c == 10) {
+        cmark_strbuf_putc(renderer->buffer, '\n');
+        renderer->column = 0;
+        renderer->begin_line = true;
+        renderer->begin_content = true;
+        renderer->last_breakable = 0;
+      } else {
+        cmark_render_code_point(renderer, c);
+        renderer->begin_line = false;
+        // we don't set 'begin_content' to false til we've
+        // finished parsing a digit.  Reason:  in commonmark
+        // we need to escape a potential list marker after
+        // a digit:
+        renderer->begin_content =
+            renderer->begin_content && cmark_isdigit((char)c) == 1;
+      }
+    } else {
+      (renderer->outc)(renderer, node, escape, c, nextc);
+      renderer->begin_line = false;
+      renderer->begin_content =
+          renderer->begin_content && cmark_isdigit((char)c) == 1;
+    }
+
+    // If adding the character went beyond width, look for an
+    // earlier place where the line could be broken:
+    if (renderer->width > 0 && renderer->column > renderer->width &&
+        !renderer->begin_line && renderer->last_breakable > 0) {
+
+      // copy from last_breakable to remainder
+      cmark_chunk_set_cstr(renderer->mem, &remainder,
+                           (char *)renderer->buffer->ptr +
+                               renderer->last_breakable + 1);
+      // truncate at last_breakable
+      cmark_strbuf_truncate(renderer->buffer, renderer->last_breakable);
+      // add newline, prefix, and remainder
+      cmark_strbuf_putc(renderer->buffer, '\n');
+      cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+                       renderer->prefix->size);
+      cmark_strbuf_put(renderer->buffer, remainder.data, remainder.len);
+      renderer->column = renderer->prefix->size + remainder.len;
+      cmark_chunk_free(renderer->mem, &remainder);
+      renderer->last_breakable = 0;
+      renderer->begin_line = false;
+      renderer->begin_content = false;
+    }
+
+    i += len;
+  }
+}
+
+// Assumes no newlines, assumes ascii content:
+void cmark_render_ascii(cmark_renderer *renderer, const char *s) {
+  int origsize = renderer->buffer->size;
+  cmark_strbuf_puts(renderer->buffer, s);
+  renderer->column += renderer->buffer->size - origsize;
+}
+
+void cmark_render_code_point(cmark_renderer *renderer, uint32_t c) {
+  cmark_utf8proc_encode_char(c, renderer->buffer);
+  renderer->column += 1;
+}
+
+char *cmark_render(cmark_mem *mem, cmark_node *root, int options, int width,
+                   void (*outc)(cmark_renderer *, cmark_node *,
+                                cmark_escaping, int32_t,
+                                unsigned char),
+                   int (*render_node)(cmark_renderer *renderer,
+                                      cmark_node *node,
+                                      cmark_event_type ev_type, int options)) {
+  cmark_strbuf pref = CMARK_BUF_INIT(mem);
+  cmark_strbuf buf = CMARK_BUF_INIT(mem);
+  cmark_node *cur;
+  cmark_event_type ev_type;
+  char *result;
+  cmark_iter *iter = cmark_iter_new(root);
+
+  cmark_renderer renderer = {mem,   &buf, &pref, 0,           width,
+                             0,     0,    true,  true,        false,
+                             false, outc, S_cr,  S_blankline, S_out,
+                             0};
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    if (!render_node(&renderer, cur, ev_type, options)) {
+      // a false value causes us to skip processing
+      // the node's contents.  this is used for
+      // autolinks.
+      cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT);
+    }
+  }
+
+  // ensure final newline
+  if (renderer.buffer->size == 0 || renderer.buffer->ptr[renderer.buffer->size - 1] != '\n') {
+    cmark_strbuf_putc(renderer.buffer, '\n');
+  }
+
+  result = (char *)cmark_strbuf_detach(renderer.buffer);
+
+  cmark_iter_free(iter);
+  cmark_strbuf_free(renderer.prefix);
+  cmark_strbuf_free(renderer.buffer);
+
+  return result;
+}

data/ext/markly/render.h

@@ -0,0 +1,62 @@
+#ifndef CMARK_RENDER_H
+#define CMARK_RENDER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include "buffer.h"
+#include "chunk.h"
+
+typedef enum { LITERAL, NORMAL, TITLE, URL } cmark_escaping;
+
+struct cmark_renderer {
+  cmark_mem *mem;
+  cmark_strbuf *buffer;
+  cmark_strbuf *prefix;
+  int column;
+  int width;
+  int need_cr;
+  bufsize_t last_breakable;
+  bool begin_line;
+  bool begin_content;
+  bool no_linebreaks;
+  bool in_tight_list_item;
+  void (*outc)(struct cmark_renderer *, cmark_node *, cmark_escaping, int32_t, unsigned char);
+  void (*cr)(struct cmark_renderer *);
+  void (*blankline)(struct cmark_renderer *);
+  void (*out)(struct cmark_renderer *, cmark_node *, const char *, bool, cmark_escaping);
+  unsigned int footnote_ix;
+};
+
+typedef struct cmark_renderer cmark_renderer;
+
+struct cmark_html_renderer {
+  cmark_strbuf *html;
+  cmark_node *plain;
+  cmark_llist *filter_extensions;
+  unsigned int footnote_ix;
+  unsigned int written_footnote_ix;
+  void *opaque;
+};
+
+typedef struct cmark_html_renderer cmark_html_renderer;
+
+void cmark_render_ascii(cmark_renderer *renderer, const char *s);
+
+void cmark_render_code_point(cmark_renderer *renderer, uint32_t c);
+
+char *cmark_render(cmark_mem *mem, cmark_node *root, int options, int width,
+                   void (*outc)(cmark_renderer *, cmark_node *,
+                                cmark_escaping, int32_t,
+                                unsigned char),
+                   int (*render_node)(cmark_renderer *renderer,
+                                      cmark_node *node,
+                                      cmark_event_type ev_type, int options));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif