markly 0.1.0

data/ext/markly/node.h

@@ -0,0 +1,118 @@
+#ifndef CMARK_NODE_H
+#define CMARK_NODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
+#include "buffer.h"
+#include "chunk.h"
+
+typedef struct {
+  cmark_list_type list_type;
+  int marker_offset;
+  int padding;
+  int start;
+  cmark_delim_type delimiter;
+  unsigned char bullet_char;
+  bool tight;
+  bool checked; // For task list extension
+} cmark_list;
+
+typedef struct {
+  cmark_chunk info;
+  cmark_chunk literal;
+  uint8_t fence_length;
+  uint8_t fence_offset;
+  unsigned char fence_char;
+  int8_t fenced;
+} cmark_code;
+
+typedef struct {
+  int level;
+  bool setext;
+} cmark_heading;
+
+typedef struct {
+  cmark_chunk url;
+  cmark_chunk title;
+} cmark_link;
+
+typedef struct {
+  cmark_chunk on_enter;
+  cmark_chunk on_exit;
+} cmark_custom;
+
+enum cmark_node__internal_flags {
+  CMARK_NODE__OPEN = (1 << 0),
+  CMARK_NODE__LAST_LINE_BLANK = (1 << 1),
+  CMARK_NODE__LAST_LINE_CHECKED = (1 << 2),
+};
+
+struct cmark_node {
+  cmark_strbuf content;
+
+  struct cmark_node *next;
+  struct cmark_node *prev;
+  struct cmark_node *parent;
+  struct cmark_node *first_child;
+  struct cmark_node *last_child;
+
+  void *user_data;
+  cmark_free_func user_data_free_func;
+
+  int start_line;
+  int start_column;
+  int end_line;
+  int end_column;
+  int internal_offset;
+  uint16_t type;
+  uint16_t flags;
+
+  cmark_syntax_extension *extension;
+
+  union {
+    cmark_chunk literal;
+    cmark_list list;
+    cmark_code code;
+    cmark_heading heading;
+    cmark_link link;
+    cmark_custom custom;
+    int html_block_type;
+    void *opaque;
+  } as;
+};
+
+static CMARK_INLINE cmark_mem *cmark_node_mem(cmark_node *node) {
+  return node->content.mem;
+}
+CMARK_GFM_EXPORT int cmark_node_check(cmark_node *node, FILE *out);
+
+static CMARK_INLINE bool CMARK_NODE_TYPE_BLOCK_P(cmark_node_type node_type) {
+	return (node_type & CMARK_NODE_TYPE_MASK) == CMARK_NODE_TYPE_BLOCK;
+}
+
+static CMARK_INLINE bool CMARK_NODE_BLOCK_P(cmark_node *node) {
+	return node != NULL && CMARK_NODE_TYPE_BLOCK_P((cmark_node_type) node->type);
+}
+
+static CMARK_INLINE bool CMARK_NODE_TYPE_INLINE_P(cmark_node_type node_type) {
+	return (node_type & CMARK_NODE_TYPE_MASK) == CMARK_NODE_TYPE_INLINE;
+}
+
+static CMARK_INLINE bool CMARK_NODE_INLINE_P(cmark_node *node) {
+	return node != NULL && CMARK_NODE_TYPE_INLINE_P((cmark_node_type) node->type);
+}
+
+CMARK_GFM_EXPORT bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/markly/parser.h

@@ -0,0 +1,58 @@
+#ifndef CMARK_PARSER_H
+#define CMARK_PARSER_H
+
+#include <stdio.h>
+#include "references.h"
+#include "node.h"
+#include "buffer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MAX_LINK_LABEL_LENGTH 1000
+
+struct cmark_parser {
+  struct cmark_mem *mem;
+  /* A hashtable of urls in the current document for cross-references */
+  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 */
+  struct cmark_node *current;
+  /* See the documentation for cmark_parser_get_line_number() in cmark.h */
+  int line_number;
+  /* See the documentation for cmark_parser_get_offset() in cmark.h */
+  bufsize_t offset;
+  /* See the documentation for cmark_parser_get_column() in cmark.h */
+  bufsize_t column;
+  /* See the documentation for cmark_parser_get_first_nonspace() in cmark.h */
+  bufsize_t first_nonspace;
+  /* See the documentation for cmark_parser_get_first_nonspace_column() in cmark.h */
+  bufsize_t first_nonspace_column;
+  bufsize_t thematic_break_kill_pos;
+  /* See the documentation for cmark_parser_get_indent() in cmark.h */
+  int indent;
+  /* See the documentation for cmark_parser_is_blank() in cmark.h */
+  bool blank;
+  /* See the documentation for cmark_parser_has_partially_consumed_tab() in cmark.h */
+  bool partially_consumed_tab;
+  /* Contains the currently processed line */
+  cmark_strbuf curline;
+  /* See the documentation for cmark_parser_get_last_line_length() in cmark.h */
+  bufsize_t last_line_length;
+  /* FIXME: not sure about the difference with curline */
+  cmark_strbuf linebuf;
+  /* Options set by the user, see the Options section in cmark.h */
+  int options;
+  bool last_buffer_ended_with_cr;
+  cmark_llist *syntax_extensions;
+  cmark_llist *inline_syntax_extensions;
+  cmark_ispunct_func backslash_ispunct;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/markly/plaintext.c

@@ -0,0 +1,235 @@
+#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)
+#define CR() renderer->cr(renderer)
+#define BLANKLINE() renderer->blankline(renderer)
+#define LISTMARKER_SIZE 20
+
+// Functions to convert cmark_nodes to plain text strings.
+
+static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_node *node, 
+                              cmark_escaping escape,
+                              int32_t c, unsigned char nextc) {
+  cmark_render_code_point(renderer, c);
+}
+
+// if node is a block node, returns node.
+// otherwise returns first block-level node that is an ancestor of node.
+// if there is no block-level ancestor, returns NULL.
+static cmark_node *get_containing_block(cmark_node *node) {
+  while (node) {
+    if (CMARK_NODE_BLOCK_P(node)) {
+      return node;
+    } else {
+      node = node->parent;
+    }
+  }
+  return NULL;
+}
+
+static int S_render_node(cmark_renderer *renderer, cmark_node *node,
+                         cmark_event_type ev_type, int options) {
+  cmark_node *tmp;
+  int list_number;
+  cmark_delim_type list_delim;
+  int i;
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  char listmarker[LISTMARKER_SIZE];
+  bool first_in_list_item;
+  bufsize_t marker_width;
+  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options) &&
+                    !(CMARK_OPT_HARDBREAKS & options);
+
+  // Don't adjust tight list status til we've started the list.
+  // Otherwise we loose the blank line between a paragraph and
+  // a following list.
+  if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && entering)) {
+    tmp = get_containing_block(node);
+    renderer->in_tight_list_item =
+        tmp && // tmp might be NULL if there is no containing block
+        ((tmp->type == CMARK_NODE_ITEM &&
+          cmark_node_get_list_tight(tmp->parent)) ||
+         (tmp && tmp->parent && tmp->parent->type == CMARK_NODE_ITEM &&
+          cmark_node_get_list_tight(tmp->parent->parent)));
+  }
+
+  if (node->extension && node->extension->plaintext_render_func) {
+    node->extension->plaintext_render_func(node->extension, renderer, node, ev_type, options);
+    return 1;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    break;
+
+  case CMARK_NODE_LIST:
+    if (!entering && node->next && (node->next->type == CMARK_NODE_CODE_BLOCK ||
+                                    node->next->type == CMARK_NODE_LIST)) {
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_ITEM:
+    if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+      marker_width = 4;
+    } else {
+      list_number = cmark_node_get_list_start(node->parent);
+      list_delim = cmark_node_get_list_delim(node->parent);
+      tmp = node;
+      while (tmp->prev) {
+        tmp = tmp->prev;
+        list_number += 1;
+      }
+      // we ensure a width of at least 4 so
+      // we get nice transition from single digits
+      // to double
+      snprintf(listmarker, LISTMARKER_SIZE, "%d%s%s", list_number,
+               list_delim == CMARK_PAREN_DELIM ? ")" : ".",
+               list_number < 10 ? "  " : " ");
+      marker_width = (bufsize_t)strlen(listmarker);
+    }
+    if (entering) {
+      if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+        LIT("  - ");
+        renderer->begin_content = true;
+      } else {
+        LIT(listmarker);
+        renderer->begin_content = true;
+      }
+      for (i = marker_width; i--;) {
+        cmark_strbuf_putc(renderer->prefix, ' ');
+      }
+    } else {
+      cmark_strbuf_truncate(renderer->prefix,
+                            renderer->prefix->size - marker_width);
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_HEADING:
+    if (entering) {
+      renderer->begin_content = true;
+      renderer->no_linebreaks = true;
+    } else {
+      renderer->no_linebreaks = false;
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_CODE_BLOCK:
+    first_in_list_item = node->prev == NULL && node->parent &&
+                         node->parent->type == CMARK_NODE_ITEM;
+
+    if (!first_in_list_item) {
+      BLANKLINE();
+    }
+    OUT(cmark_node_get_literal(node), false, LITERAL);
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_HTML_BLOCK:
+    break;
+
+  case CMARK_NODE_CUSTOM_BLOCK:
+    break;
+
+  case CMARK_NODE_THEMATIC_BREAK:
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_PARAGRAPH:
+    if (!entering) {
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_TEXT:
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
+    break;
+
+  case CMARK_NODE_LINEBREAK:
+    CR();
+    break;
+
+  case CMARK_NODE_SOFTBREAK:
+    if (CMARK_OPT_HARDBREAKS & options) {
+      CR();
+    } else if (!renderer->no_linebreaks && renderer->width == 0 &&
+               !(CMARK_OPT_HARDBREAKS & options) &&
+               !(CMARK_OPT_NOBREAKS & options)) {
+      CR();
+    } else {
+      OUT(" ", allow_wrap, LITERAL);
+    }
+    break;
+
+  case CMARK_NODE_CODE:
+    OUT(cmark_node_get_literal(node), allow_wrap, LITERAL);
+    break;
+
+  case CMARK_NODE_HTML_INLINE:
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE:
+    break;
+
+  case CMARK_NODE_STRONG:
+    break;
+
+  case CMARK_NODE_EMPH:
+    break;
+
+  case CMARK_NODE_LINK:
+    break;
+
+  case CMARK_NODE_IMAGE:
+    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("]: ");
+
+      cmark_strbuf_puts(renderer->prefix, "    ");
+    } else {
+      cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 4);
+    }
+    break;
+  default:
+    assert(false);
+    break;
+  }
+
+  return 1;
+}
+
+char *cmark_render_plaintext(cmark_node *root, int options, int width) {
+  return cmark_render_plaintext_with_mem(root, options, width, cmark_node_mem(root));
+}
+
+char *cmark_render_plaintext_with_mem(cmark_node *root, int options, int width, cmark_mem *mem) {
+  if (options & CMARK_OPT_HARDBREAKS) {
+    // disable breaking on width, since it has
+    // a different meaning with OPT_HARDBREAKS
+    width = 0;
+  }
+  return cmark_render(mem, root, options, width, outc, S_render_node);
+}

data/ext/markly/plugin.c

@@ -0,0 +1,36 @@
+#include <stdlib.h>
+
+#include "plugin.h"
+
+extern cmark_mem CMARK_DEFAULT_MEM_ALLOCATOR;
+
+int cmark_plugin_register_syntax_extension(cmark_plugin    * plugin,
+                                        cmark_syntax_extension * extension) {
+  plugin->syntax_extensions = cmark_llist_append(&CMARK_DEFAULT_MEM_ALLOCATOR, plugin->syntax_extensions, extension);
+  return 1;
+}
+
+cmark_plugin *
+cmark_plugin_new(void) {
+  cmark_plugin *res = (cmark_plugin *) CMARK_DEFAULT_MEM_ALLOCATOR.calloc(1, sizeof(cmark_plugin));
+
+  res->syntax_extensions = NULL;
+
+  return res;
+}
+
+void
+cmark_plugin_free(cmark_plugin *plugin) {
+  cmark_llist_free_full(&CMARK_DEFAULT_MEM_ALLOCATOR,
+                        plugin->syntax_extensions,
+                        (cmark_free_func) cmark_syntax_extension_free);
+  CMARK_DEFAULT_MEM_ALLOCATOR.free(plugin);
+}
+
+cmark_llist *
+cmark_plugin_steal_syntax_extensions(cmark_plugin *plugin) {
+  cmark_llist *res = plugin->syntax_extensions;
+
+  plugin->syntax_extensions = NULL;
+  return res;
+}