commonmarker 0.23.10 → 2.2.0

data/ext/commonmarker/node.h

@@ -1,167 +0,0 @@
-#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),
-
-  // Extensions can register custom flags by calling `cmark_register_node_flag`.
-  // This is the starting value for the custom flags.
-  CMARK_NODE__REGISTER_FIRST = (1 << 3),
-};
-
-typedef uint16_t cmark_node_internal_flags;
-
-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;
-  cmark_node_internal_flags flags;
-
-  cmark_syntax_extension *extension;
-
-  /**
-   * Used during cmark_render() to cache the most recent non-NULL
-   * extension, if you go up the parent chain like this:
-   *
-   * node->parent->...parent->extension
-   */
-  cmark_syntax_extension *ancestor_extension;
-
-  union {
-    int ref_ix;
-    int def_count;
-  } footnote;
-
-  cmark_node *parent_footnote_def;
-
-  union {
-    cmark_chunk literal;
-    cmark_list list;
-    cmark_code code;
-    cmark_heading heading;
-    cmark_link link;
-    cmark_custom custom;
-    int html_block_type;
-    int cell_index; // For keeping track of TABLE_CELL table alignments
-    void *opaque;
-  } as;
-};
-
-/**
- * Syntax extensions can use this function to register a custom node
- * flag. The flags are stored in the `flags` field of the `cmark_node`
- * struct. The `flags` parameter should be the address of a global variable
- * which will store the flag value.
- */
-CMARK_GFM_EXPORT
-void cmark_register_node_flag(cmark_node_internal_flags *flags);
-
-/**
- * DEPRECATED.
- *
- * This function was added in cmark-gfm version 0.29.0.gfm.7, and was
- * required to be called at program start time, which caused
- * backwards-compatibility issues in applications that use cmark-gfm as a
- * library. It is now a no-op.
- */
-CMARK_GFM_EXPORT
-void cmark_init_standard_node_flags(void);
-
-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);
-
-/**
- * Enable (or disable) extra safety checks. These extra checks cause
- * extra performance overhead (in some cases quadratic), so they are only
- * intended to be used during testing.
- */
-CMARK_GFM_EXPORT void cmark_enable_safety_checks(bool enable);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

data/ext/commonmarker/parser.h

@@ -1,59 +0,0 @@
-#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;
-  size_t total_size;
-  cmark_llist *syntax_extensions;
-  cmark_llist *inline_syntax_extensions;
-  cmark_ispunct_func backslash_ispunct;
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

data/ext/commonmarker/plaintext.c

@@ -1,218 +0,0 @@
-#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);
-}
-
-static int S_render_node(cmark_renderer *renderer, cmark_node *node,
-                         cmark_event_type ev_type, int options) {
-  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 (entering) {
-    if (node->parent && node->parent->type == CMARK_NODE_ITEM) {
-      renderer->in_tight_list_item = node->parent->parent->as.list.tight;
-    }
-  } else {
-    if (node->type == CMARK_NODE_LIST) {
-      renderer->in_tight_list_item =
-        node->parent &&
-        node->parent->type == CMARK_NODE_ITEM &&
-        node->parent->parent->as.list.tight;
-    }
-  }
-
-  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_item_index(node);
-      list_delim = cmark_node_get_list_delim(node->parent);
-      // 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/commonmarker/plugin.c

@@ -1,36 +0,0 @@
-#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;
-}

data/ext/commonmarker/plugin.h

@@ -1,34 +0,0 @@
-#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/commonmarker/references.c

@@ -1,43 +0,0 @@
-#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;
-  ref->entry.size = ref->url.len + ref->title.len;
-
-  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/commonmarker/references.h

@@ -1,26 +0,0 @@
-#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/commonmarker/registry.c

@@ -1,63 +0,0 @@
-#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/commonmarker/registry.h

@@ -1,24 +0,0 @@
-#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