commonmarker 0.23.10 → 2.2.0

data/ext/commonmarker/inlines.h

@@ -1,29 +0,0 @@
-#ifndef CMARK_INLINES_H
-#define CMARK_INLINES_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "references.h"
-
-cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url);
-cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title);
-
-CMARK_GFM_EXPORT
-void cmark_parse_inlines(cmark_parser *parser,
-                         cmark_node *parent,
-                         cmark_map *refmap,
-                         int options);
-
-bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
-                                       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);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

data/ext/commonmarker/iterator.c

@@ -1,159 +0,0 @@
-#include <assert.h>
-#include <stdlib.h>
-
-#include "config.h"
-#include "node.h"
-#include "cmark-gfm.h"
-#include "iterator.h"
-
-cmark_iter *cmark_iter_new(cmark_node *root) {
-  if (root == NULL) {
-    return NULL;
-  }
-  cmark_mem *mem = root->content.mem;
-  cmark_iter *iter = (cmark_iter *)mem->calloc(1, sizeof(cmark_iter));
-  iter->mem = mem;
-  iter->root = root;
-  iter->cur.ev_type = CMARK_EVENT_NONE;
-  iter->cur.node = NULL;
-  iter->next.ev_type = CMARK_EVENT_ENTER;
-  iter->next.node = root;
-  return iter;
-}
-
-void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter); }
-
-static bool S_is_leaf(cmark_node *node) {
-  switch (node->type) {
-  case CMARK_NODE_HTML_BLOCK:
-  case CMARK_NODE_THEMATIC_BREAK:
-  case CMARK_NODE_CODE_BLOCK:
-  case CMARK_NODE_TEXT:
-  case CMARK_NODE_SOFTBREAK:
-  case CMARK_NODE_LINEBREAK:
-  case CMARK_NODE_CODE:
-  case CMARK_NODE_HTML_INLINE:
-    return 1;
-  }
-  return 0;
-}
-
-cmark_event_type cmark_iter_next(cmark_iter *iter) {
-  cmark_event_type ev_type = iter->next.ev_type;
-  cmark_node *node = iter->next.node;
-
-  iter->cur.ev_type = ev_type;
-  iter->cur.node = node;
-
-  if (ev_type == CMARK_EVENT_DONE) {
-    return ev_type;
-  }
-
-  /* roll forward to next item, setting both fields */
-  if (ev_type == CMARK_EVENT_ENTER && !S_is_leaf(node)) {
-    if (node->first_child == NULL) {
-      /* stay on this node but exit */
-      iter->next.ev_type = CMARK_EVENT_EXIT;
-    } else {
-      iter->next.ev_type = CMARK_EVENT_ENTER;
-      iter->next.node = node->first_child;
-    }
-  } else if (node == iter->root) {
-    /* don't move past root */
-    iter->next.ev_type = CMARK_EVENT_DONE;
-    iter->next.node = NULL;
-  } else if (node->next) {
-    iter->next.ev_type = CMARK_EVENT_ENTER;
-    iter->next.node = node->next;
-  } else if (node->parent) {
-    iter->next.ev_type = CMARK_EVENT_EXIT;
-    iter->next.node = node->parent;
-  } else {
-    assert(false);
-    iter->next.ev_type = CMARK_EVENT_DONE;
-    iter->next.node = NULL;
-  }
-
-  return ev_type;
-}
-
-void cmark_iter_reset(cmark_iter *iter, cmark_node *current,
-                      cmark_event_type event_type) {
-  iter->next.ev_type = event_type;
-  iter->next.node = current;
-  cmark_iter_next(iter);
-}
-
-cmark_node *cmark_iter_get_node(cmark_iter *iter) { return iter->cur.node; }
-
-cmark_event_type cmark_iter_get_event_type(cmark_iter *iter) {
-  return iter->cur.ev_type;
-}
-
-cmark_node *cmark_iter_get_root(cmark_iter *iter) { return iter->root; }
-
-void cmark_consolidate_text_nodes(cmark_node *root) {
-  if (root == NULL) {
-    return;
-  }
-  cmark_iter *iter = cmark_iter_new(root);
-  cmark_strbuf buf = CMARK_BUF_INIT(iter->mem);
-  cmark_event_type ev_type;
-  cmark_node *cur, *tmp, *next;
-
-  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
-    cur = cmark_iter_get_node(iter);
-    if (ev_type == CMARK_EVENT_ENTER && cur->type == CMARK_NODE_TEXT &&
-        cur->next && cur->next->type == CMARK_NODE_TEXT) {
-      cmark_strbuf_clear(&buf);
-      cmark_strbuf_put(&buf, cur->as.literal.data, cur->as.literal.len);
-      tmp = cur->next;
-      while (tmp && tmp->type == CMARK_NODE_TEXT) {
-        cmark_iter_next(iter); // advance pointer
-        cmark_strbuf_put(&buf, tmp->as.literal.data, tmp->as.literal.len);
-        cur->end_column = tmp->end_column;
-        next = tmp->next;
-        cmark_node_free(tmp);
-        tmp = next;
-      }
-      cmark_chunk_free(iter->mem, &cur->as.literal);
-      cur->as.literal = cmark_chunk_buf_detach(&buf);
-    }
-  }
-
-  cmark_strbuf_free(&buf);
-  cmark_iter_free(iter);
-}
-
-void cmark_node_own(cmark_node *root) {
-  if (root == NULL) {
-    return;
-  }
-  cmark_iter *iter = cmark_iter_new(root);
-  cmark_event_type ev_type;
-  cmark_node *cur;
-
-  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
-    cur = cmark_iter_get_node(iter);
-    if (ev_type == CMARK_EVENT_ENTER) {
-      switch (cur->type) {
-      case CMARK_NODE_TEXT:
-      case CMARK_NODE_HTML_INLINE:
-      case CMARK_NODE_CODE:
-      case CMARK_NODE_HTML_BLOCK:
-        cmark_chunk_to_cstr(iter->mem, &cur->as.literal);
-        break;
-      case CMARK_NODE_LINK:
-        cmark_chunk_to_cstr(iter->mem, &cur->as.link.url);
-        cmark_chunk_to_cstr(iter->mem, &cur->as.link.title);
-        break;
-      case CMARK_NODE_CUSTOM_INLINE:
-        cmark_chunk_to_cstr(iter->mem, &cur->as.custom.on_enter);
-        cmark_chunk_to_cstr(iter->mem, &cur->as.custom.on_exit);
-        break;
-      }
-    }
-  }
-
-  cmark_iter_free(iter);
-}

data/ext/commonmarker/iterator.h

@@ -1,26 +0,0 @@
-#ifndef CMARK_ITERATOR_H
-#define CMARK_ITERATOR_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "cmark-gfm.h"
-
-typedef struct {
-  cmark_event_type ev_type;
-  cmark_node *node;
-} cmark_iter_state;
-
-struct cmark_iter {
-  cmark_mem *mem;
-  cmark_node *root;
-  cmark_iter_state cur;
-  cmark_iter_state next;
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

data/ext/commonmarker/latex.c

@@ -1,468 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-
-#include "config.h"
-#include "cmark-gfm.h"
-#include "node.h"
-#include "buffer.h"
-#include "utf8.h"
-#include "scanners.h"
-#include "render.h"
-#include "syntax_extension.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 LIST_NUMBER_STRING_SIZE 20
-
-static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_node *node,
-                              cmark_escaping escape,
-                              int32_t c, unsigned char nextc) {
-  if (escape == LITERAL) {
-    cmark_render_code_point(renderer, c);
-    return;
-  }
-
-  switch (c) {
-  case 123: // '{'
-  case 125: // '}'
-  case 35:  // '#'
-  case 37:  // '%'
-  case 38:  // '&'
-    cmark_render_ascii(renderer, "\\");
-    cmark_render_code_point(renderer, c);
-    break;
-  case 36: // '$'
-  case 95: // '_'
-    if (escape == NORMAL) {
-      cmark_render_ascii(renderer, "\\");
-    }
-    cmark_render_code_point(renderer, c);
-    break;
-  case 45:             // '-'
-    if (nextc == 45) { // prevent ligature
-      cmark_render_ascii(renderer, "-{}");
-    } else {
-      cmark_render_ascii(renderer, "-");
-    }
-    break;
-  case 126: // '~'
-    if (escape == NORMAL) {
-      cmark_render_ascii(renderer, "\\textasciitilde{}");
-    } else {
-      cmark_render_code_point(renderer, c);
-    }
-    break;
-  case 94: // '^'
-    cmark_render_ascii(renderer, "\\^{}");
-    break;
-  case 92: // '\\'
-    if (escape == URL) {
-      // / acts as path sep even on windows:
-      cmark_render_ascii(renderer, "/");
-    } else {
-      cmark_render_ascii(renderer, "\\textbackslash{}");
-    }
-    break;
-  case 124: // '|'
-    cmark_render_ascii(renderer, "\\textbar{}");
-    break;
-  case 60: // '<'
-    cmark_render_ascii(renderer, "\\textless{}");
-    break;
-  case 62: // '>'
-    cmark_render_ascii(renderer, "\\textgreater{}");
-    break;
-  case 91: // '['
-  case 93: // ']'
-    cmark_render_ascii(renderer, "{");
-    cmark_render_code_point(renderer, c);
-    cmark_render_ascii(renderer, "}");
-    break;
-  case 34: // '"'
-    cmark_render_ascii(renderer, "\\textquotedbl{}");
-    // requires \usepackage[T1]{fontenc}
-    break;
-  case 39: // '\''
-    cmark_render_ascii(renderer, "\\textquotesingle{}");
-    // requires \usepackage{textcomp}
-    break;
-  case 160: // nbsp
-    cmark_render_ascii(renderer, "~");
-    break;
-  case 8230: // hellip
-    cmark_render_ascii(renderer, "\\ldots{}");
-    break;
-  case 8216: // lsquo
-    if (escape == NORMAL) {
-      cmark_render_ascii(renderer, "`");
-    } else {
-      cmark_render_code_point(renderer, c);
-    }
-    break;
-  case 8217: // rsquo
-    if (escape == NORMAL) {
-      cmark_render_ascii(renderer, "\'");
-    } else {
-      cmark_render_code_point(renderer, c);
-    }
-    break;
-  case 8220: // ldquo
-    if (escape == NORMAL) {
-      cmark_render_ascii(renderer, "``");
-    } else {
-      cmark_render_code_point(renderer, c);
-    }
-    break;
-  case 8221: // rdquo
-    if (escape == NORMAL) {
-      cmark_render_ascii(renderer, "''");
-    } else {
-      cmark_render_code_point(renderer, c);
-    }
-    break;
-  case 8212: // emdash
-    if (escape == NORMAL) {
-      cmark_render_ascii(renderer, "---");
-    } else {
-      cmark_render_code_point(renderer, c);
-    }
-    break;
-  case 8211: // endash
-    if (escape == NORMAL) {
-      cmark_render_ascii(renderer, "--");
-    } else {
-      cmark_render_code_point(renderer, c);
-    }
-    break;
-  default:
-    cmark_render_code_point(renderer, c);
-  }
-}
-
-typedef enum {
-  NO_LINK,
-  URL_AUTOLINK,
-  EMAIL_AUTOLINK,
-  NORMAL_LINK,
-  INTERNAL_LINK
-} link_type;
-
-static link_type get_link_type(cmark_node *node) {
-  size_t title_len, url_len;
-  cmark_node *link_text;
-  char *realurl;
-  int realurllen;
-  bool isemail = false;
-
-  if (node->type != CMARK_NODE_LINK) {
-    return NO_LINK;
-  }
-
-  const char *url = cmark_node_get_url(node);
-  cmark_chunk url_chunk = cmark_chunk_literal(url);
-
-  if (url && *url == '#') {
-    return INTERNAL_LINK;
-  }
-
-  url_len = strlen(url);
-  if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) {
-    return NO_LINK;
-  }
-
-  const char *title = cmark_node_get_title(node);
-  title_len = strlen(title);
-  // if it has a title, we can't treat it as an autolink:
-  if (title_len == 0) {
-
-    link_text = node->first_child;
-    cmark_consolidate_text_nodes(link_text);
-
-    if (!link_text)
-      return NO_LINK;
-
-    realurl = (char *)url;
-    realurllen = (int)url_len;
-    if (strncmp(realurl, "mailto:", 7) == 0) {
-      realurl += 7;
-      realurllen -= 7;
-      isemail = true;
-    }
-    if (realurllen == link_text->as.literal.len &&
-        strncmp(realurl, (char *)link_text->as.literal.data,
-                link_text->as.literal.len) == 0) {
-      if (isemail) {
-        return EMAIL_AUTOLINK;
-      } else {
-        return URL_AUTOLINK;
-      }
-    }
-  }
-
-  return NORMAL_LINK;
-}
-
-static int S_get_enumlevel(cmark_node *node) {
-  int enumlevel = 0;
-  cmark_node *tmp = node;
-  while (tmp) {
-    if (tmp->type == CMARK_NODE_LIST &&
-        cmark_node_get_list_type(node) == CMARK_ORDERED_LIST) {
-      enumlevel++;
-    }
-    tmp = tmp->parent;
-  }
-  return enumlevel;
-}
-
-static int S_render_node(cmark_renderer *renderer, cmark_node *node,
-                         cmark_event_type ev_type, int options) {
-  int list_number;
-  int enumlevel;
-  char list_number_string[LIST_NUMBER_STRING_SIZE];
-  bool entering = (ev_type == CMARK_EVENT_ENTER);
-  cmark_list_type list_type;
-  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options);
-
-  if (node->extension && node->extension->latex_render_func) {
-    node->extension->latex_render_func(node->extension, renderer, node, ev_type, options);
-    return 1;
-  }
-
-  switch (node->type) {
-  case CMARK_NODE_DOCUMENT:
-    break;
-
-  case CMARK_NODE_BLOCK_QUOTE:
-    if (entering) {
-      LIT("\\begin{quote}");
-      CR();
-    } else {
-      LIT("\\end{quote}");
-      BLANKLINE();
-    }
-    break;
-
-  case CMARK_NODE_LIST:
-    list_type = cmark_node_get_list_type(node);
-    if (entering) {
-      LIT("\\begin{");
-      LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize");
-      LIT("}");
-      CR();
-      list_number = cmark_node_get_list_start(node);
-      if (list_number > 1) {
-        enumlevel = S_get_enumlevel(node);
-        // latex normally supports only five levels
-        if (enumlevel >= 1 && enumlevel <= 5) {
-          snprintf(list_number_string, LIST_NUMBER_STRING_SIZE, "%d",
-                   list_number);
-          LIT("\\setcounter{enum");
-          switch (enumlevel) {
-          case 1: LIT("i"); break;
-          case 2: LIT("ii"); break;
-          case 3: LIT("iii"); break;
-          case 4: LIT("iv"); break;
-          case 5: LIT("v"); break;
-          default: LIT("i"); break;
-	  }
-          LIT("}{");
-          OUT(list_number_string, false, NORMAL);
-          LIT("}");
-        }
-        CR();
-      }
-    } else {
-      LIT("\\end{");
-      LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize");
-      LIT("}");
-      BLANKLINE();
-    }
-    break;
-
-  case CMARK_NODE_ITEM:
-    if (entering) {
-      LIT("\\item ");
-    } else {
-      CR();
-    }
-    break;
-
-  case CMARK_NODE_HEADING:
-    if (entering) {
-      switch (cmark_node_get_heading_level(node)) {
-      case 1:
-        LIT("\\section");
-        break;
-      case 2:
-        LIT("\\subsection");
-        break;
-      case 3:
-        LIT("\\subsubsection");
-        break;
-      case 4:
-        LIT("\\paragraph");
-        break;
-      case 5:
-        LIT("\\subparagraph");
-        break;
-      }
-      LIT("{");
-    } else {
-      LIT("}");
-      BLANKLINE();
-    }
-    break;
-
-  case CMARK_NODE_CODE_BLOCK:
-    CR();
-    LIT("\\begin{verbatim}");
-    CR();
-    OUT(cmark_node_get_literal(node), false, LITERAL);
-    CR();
-    LIT("\\end{verbatim}");
-    BLANKLINE();
-    break;
-
-  case CMARK_NODE_HTML_BLOCK:
-    break;
-
-  case CMARK_NODE_CUSTOM_BLOCK:
-    CR();
-    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
-        false, LITERAL);
-    CR();
-    break;
-
-  case CMARK_NODE_THEMATIC_BREAK:
-    BLANKLINE();
-    LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}");
-    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:
-    LIT("\\\\");
-    CR();
-    break;
-
-  case CMARK_NODE_SOFTBREAK:
-    if (options & CMARK_OPT_HARDBREAKS) {
-      LIT("\\\\");
-      CR();
-    } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) {
-      CR();
-    } else {
-      OUT(" ", allow_wrap, NORMAL);
-    }
-    break;
-
-  case CMARK_NODE_CODE:
-    LIT("\\texttt{");
-    OUT(cmark_node_get_literal(node), false, NORMAL);
-    LIT("}");
-    break;
-
-  case CMARK_NODE_HTML_INLINE:
-    break;
-
-  case CMARK_NODE_CUSTOM_INLINE:
-    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
-        false, LITERAL);
-    break;
-
-  case CMARK_NODE_STRONG:
-    if (node->parent == NULL || node->parent->type != CMARK_NODE_STRONG) {
-      if (entering) {
-        LIT("\\textbf{");
-      } else {
-        LIT("}");
-      }
-    }
-    break;
-
-  case CMARK_NODE_EMPH:
-    if (entering) {
-      LIT("\\emph{");
-    } else {
-      LIT("}");
-    }
-    break;
-
-  case CMARK_NODE_LINK:
-    if (entering) {
-      const char *url = cmark_node_get_url(node);
-      // requires \usepackage{hyperref}
-      switch (get_link_type(node)) {
-      case URL_AUTOLINK:
-        LIT("\\url{");
-        OUT(url, false, URL);
-        LIT("}");
-        return 0; // Don't process further nodes to avoid double-rendering artefacts
-      case EMAIL_AUTOLINK:
-        LIT("\\href{");
-        OUT(url, false, URL);
-        LIT("}\\nolinkurl{");
-        break;
-      case NORMAL_LINK:
-        LIT("\\href{");
-        OUT(url, false, URL);
-        LIT("}{");
-        break;
-      case INTERNAL_LINK:
-        LIT("\\protect\\hyperlink{");
-        OUT(url + 1, false, URL);
-        LIT("}{");
-        break;
-      case NO_LINK:
-        LIT("{"); // error?
-      }
-    } else {
-      LIT("}");
-    }
-
-    break;
-
-  case CMARK_NODE_IMAGE:
-    if (entering) {
-      LIT("\\protect\\includegraphics{");
-      // requires \include{graphicx}
-      OUT(cmark_node_get_url(node), false, URL);
-      LIT("}");
-      return 0;
-    }
-    break;
-
-  case CMARK_NODE_FOOTNOTE_DEFINITION:
-  case CMARK_NODE_FOOTNOTE_REFERENCE:
-    // TODO
-    break;
-
-  default:
-    assert(false);
-    break;
-  }
-
-  return 1;
-}
-
-char *cmark_render_latex(cmark_node *root, int options, int width) {
-  return cmark_render_latex_with_mem(root, options, width, cmark_node_mem(root));
-}
-
-char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmark_mem *mem) {
-  return cmark_render(mem, root, options, width, outc, S_render_node);
-}

data/ext/commonmarker/linked_list.c

@@ -1,37 +0,0 @@
-#include <stdlib.h>
-
-#include "cmark-gfm.h"
-
-cmark_llist *cmark_llist_append(cmark_mem *mem, cmark_llist *head, void *data) {
-  cmark_llist *tmp;
-  cmark_llist *new_node = (cmark_llist *) mem->calloc(1, sizeof(cmark_llist));
-
-  new_node->data = data;
-  new_node->next = NULL;
-
-  if (!head)
-    return new_node;
-
-  for (tmp = head; tmp->next; tmp=tmp->next);
-
-  tmp->next = new_node;
-
-  return head;
-}
-
-void cmark_llist_free_full(cmark_mem *mem, cmark_llist *head, cmark_free_func free_func) {
-  cmark_llist *tmp, *prev;
-
-  for (tmp = head; tmp;) {
-    if (free_func)
-      free_func(mem, tmp->data);
-
-    prev = tmp;
-    tmp = tmp->next;
-    mem->free(prev);
-  }
-}
-
-void cmark_llist_free(cmark_mem *mem, cmark_llist *head) {
-  cmark_llist_free_full(mem, head, NULL);
-}