commonmarker 0.23.9 → 1.0.0.pre

data/ext/commonmarker/man.c

@@ -1,274 +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 "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_SIZE 20
-
-// Functions to convert cmark_nodes to groff man strings.
-static void S_outc(cmark_renderer *renderer, cmark_node *node, 
-                   cmark_escaping escape, int32_t c,
-                   unsigned char nextc) {
-  (void)(nextc);
-
-  if (escape == LITERAL) {
-    cmark_render_code_point(renderer, c);
-    return;
-  }
-
-  switch (c) {
-  case 46:
-    if (renderer->begin_line) {
-      cmark_render_ascii(renderer, "\\&.");
-    } else {
-      cmark_render_code_point(renderer, c);
-    }
-    break;
-  case 39:
-    if (renderer->begin_line) {
-      cmark_render_ascii(renderer, "\\&'");
-    } else {
-      cmark_render_code_point(renderer, c);
-    }
-    break;
-  case 45:
-    cmark_render_ascii(renderer, "\\-");
-    break;
-  case 92:
-    cmark_render_ascii(renderer, "\\e");
-    break;
-  case 8216: // left single quote
-    cmark_render_ascii(renderer, "\\[oq]");
-    break;
-  case 8217: // right single quote
-    cmark_render_ascii(renderer, "\\[cq]");
-    break;
-  case 8220: // left double quote
-    cmark_render_ascii(renderer, "\\[lq]");
-    break;
-  case 8221: // right double quote
-    cmark_render_ascii(renderer, "\\[rq]");
-    break;
-  case 8212: // em dash
-    cmark_render_ascii(renderer, "\\[em]");
-    break;
-  case 8211: // en dash
-    cmark_render_ascii(renderer, "\\[en]");
-    break;
-  default:
-    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;
-  bool entering = (ev_type == CMARK_EVENT_ENTER);
-  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options);
-
-  if (node->extension && node->extension->man_render_func) {
-    node->extension->man_render_func(node->extension, renderer, node, ev_type, options);
-    return 1;
-  }
-
-  switch (node->type) {
-  case CMARK_NODE_DOCUMENT:
-    if (entering) {
-      /* Define a strikethrough macro */
-      /* Commenting out because this makes tests fail
-      LIT(".de ST");
-      CR();
-      LIT(".nr ww \\w'\\\\$1'");
-      CR();
-      LIT("\\Z@\\v'-.25m'\\l'\\\\n[ww]u'@\\\\$1");
-      CR();
-      LIT("..");
-      CR();
-      */
-    }
-    break;
-
-  case CMARK_NODE_BLOCK_QUOTE:
-    if (entering) {
-      CR();
-      LIT(".RS");
-      CR();
-    } else {
-      CR();
-      LIT(".RE");
-      CR();
-    }
-    break;
-
-  case CMARK_NODE_LIST:
-    break;
-
-  case CMARK_NODE_ITEM:
-    if (entering) {
-      CR();
-      LIT(".IP ");
-      if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
-        LIT("\\[bu] 2");
-      } else {
-        list_number = cmark_node_get_item_index(node);
-        char list_number_s[LIST_NUMBER_SIZE];
-        snprintf(list_number_s, LIST_NUMBER_SIZE, "\"%d.\" 4", list_number);
-        LIT(list_number_s);
-      }
-      CR();
-    } else {
-      CR();
-    }
-    break;
-
-  case CMARK_NODE_HEADING:
-    if (entering) {
-      CR();
-      LIT(cmark_node_get_heading_level(node) == 1 ? ".SH" : ".SS");
-      CR();
-    } else {
-      CR();
-    }
-    break;
-
-  case CMARK_NODE_CODE_BLOCK:
-    CR();
-    LIT(".IP\n.nf\n\\f[C]\n");
-    OUT(cmark_node_get_literal(node), false, NORMAL);
-    CR();
-    LIT("\\f[]\n.fi");
-    CR();
-    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:
-    CR();
-    LIT(".PP\n  *  *  *  *  *");
-    CR();
-    break;
-
-  case CMARK_NODE_PARAGRAPH:
-    if (entering) {
-      // no blank line if first paragraph in list:
-      if (node->parent && node->parent->type == CMARK_NODE_ITEM &&
-          node->prev == NULL) {
-        // no blank line or .PP
-      } else {
-        CR();
-        LIT(".PP");
-        CR();
-      }
-    } else {
-      CR();
-    }
-    break;
-
-  case CMARK_NODE_TEXT:
-    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
-    break;
-
-  case CMARK_NODE_LINEBREAK:
-    LIT(".PD 0\n.P\n.PD");
-    CR();
-    break;
-
-  case CMARK_NODE_SOFTBREAK:
-    if (options & CMARK_OPT_HARDBREAKS) {
-      LIT(".PD 0\n.P\n.PD");
-      CR();
-    } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) {
-      CR();
-    } else {
-      OUT(" ", allow_wrap, LITERAL);
-    }
-    break;
-
-  case CMARK_NODE_CODE:
-    LIT("\\f[C]");
-    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
-    LIT("\\f[]");
-    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("\\f[B]");
-      } else {
-        LIT("\\f[]");
-      }
-    }
-    break;
-
-  case CMARK_NODE_EMPH:
-    if (entering) {
-      LIT("\\f[I]");
-    } else {
-      LIT("\\f[]");
-    }
-    break;
-
-  case CMARK_NODE_LINK:
-    if (!entering) {
-      LIT(" (");
-      OUT(cmark_node_get_url(node), allow_wrap, URL);
-      LIT(")");
-    }
-    break;
-
-  case CMARK_NODE_IMAGE:
-    if (entering) {
-      LIT("[IMAGE: ");
-    } else {
-      LIT("]");
-    }
-    break;
-
-  case CMARK_NODE_FOOTNOTE_DEFINITION:
-  case CMARK_NODE_FOOTNOTE_REFERENCE:
-    // TODO
-    break;
-
-  default:
-    assert(false);
-    break;
-  }
-
-  return 1;
-}
-
-char *cmark_render_man(cmark_node *root, int options, int width) {
-  return cmark_render_man_with_mem(root, options, width, cmark_node_mem(root));
-}
-
-char *cmark_render_man_with_mem(cmark_node *root, int options, int width, cmark_mem *mem) {
-  return cmark_render(mem, root, options, width, S_outc, S_render_node);
-}

data/ext/commonmarker/map.c

@@ -1,129 +0,0 @@
-#include "map.h"
-#include "utf8.h"
-#include "parser.h"
-
-// normalize map label:  collapse internal whitespace to single space,
-// remove leading/trailing whitespace, case fold
-// Return NULL if the label is actually empty (i.e. composed solely from
-// whitespace)
-unsigned char *normalize_map_label(cmark_mem *mem, cmark_chunk *ref) {
-  cmark_strbuf normalized = CMARK_BUF_INIT(mem);
-  unsigned char *result;
-
-  if (ref == NULL)
-    return NULL;
-
-  if (ref->len == 0)
-    return NULL;
-
-  cmark_utf8proc_case_fold(&normalized, ref->data, ref->len);
-  cmark_strbuf_trim(&normalized);
-  cmark_strbuf_normalize_whitespace(&normalized);
-
-  result = cmark_strbuf_detach(&normalized);
-  assert(result);
-
-  if (result[0] == '\0') {
-    mem->free(result);
-    return NULL;
-  }
-
-  return result;
-}
-
-static int
-labelcmp(const unsigned char *a, const unsigned char *b) {
-  return strcmp((const char *)a, (const char *)b);
-}
-
-static int
-refcmp(const void *p1, const void *p2) {
-  cmark_map_entry *r1 = *(cmark_map_entry **)p1;
-  cmark_map_entry *r2 = *(cmark_map_entry **)p2;
-  int res = labelcmp(r1->label, r2->label);
-  return res ? res : ((int)r1->age - (int)r2->age);
-}
-
-static int
-refsearch(const void *label, const void *p2) {
-  cmark_map_entry *ref = *(cmark_map_entry **)p2;
-  return labelcmp((const unsigned char *)label, ref->label);
-}
-
-static void sort_map(cmark_map *map) {
-  size_t i = 0, last = 0, size = map->size;
-  cmark_map_entry *r = map->refs, **sorted = NULL;
-
-  sorted = (cmark_map_entry **)map->mem->calloc(size, sizeof(cmark_map_entry *));
-  while (r) {
-    sorted[i++] = r;
-    r = r->next;
-  }
-
-  qsort(sorted, size, sizeof(cmark_map_entry *), refcmp);
-
-  for (i = 1; i < size; i++) {
-    if (labelcmp(sorted[i]->label, sorted[last]->label) != 0)
-      sorted[++last] = sorted[i];
-  }
-
-  map->sorted = sorted;
-  map->size = last + 1;
-}
-
-cmark_map_entry *cmark_map_lookup(cmark_map *map, cmark_chunk *label) {
-  cmark_map_entry **ref = NULL;
-  cmark_map_entry *r = NULL;
-  unsigned char *norm;
-
-  if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH)
-    return NULL;
-
-  if (map == NULL || !map->size)
-    return NULL;
-
-  norm = normalize_map_label(map->mem, label);
-  if (norm == NULL)
-    return NULL;
-
-  if (!map->sorted)
-    sort_map(map);
-
-  ref = (cmark_map_entry **)bsearch(norm, map->sorted, map->size, sizeof(cmark_map_entry *), refsearch);
-  map->mem->free(norm);
-
-  if (ref != NULL) {
-    r = ref[0];
-    /* Check for expansion limit */
-    if (r->size > map->max_ref_size - map->ref_size)
-      return NULL;
-    map->ref_size += r->size;
-  }
-
-  return r;
-}
-
-void cmark_map_free(cmark_map *map) {
-  cmark_map_entry *ref;
-
-  if (map == NULL)
-    return;
-
-  ref = map->refs;
-  while (ref) {
-    cmark_map_entry *next = ref->next;
-    map->free(map, ref);
-    ref = next;
-  }
-
-  map->mem->free(map->sorted);
-  map->mem->free(map);
-}
-
-cmark_map *cmark_map_new(cmark_mem *mem, cmark_map_free_f free) {
-  cmark_map *map = (cmark_map *)mem->calloc(1, sizeof(cmark_map));
-  map->mem = mem;
-  map->free = free;
-  map->max_ref_size = UINT_MAX;
-  return map;
-}

data/ext/commonmarker/map.h

@@ -1,44 +0,0 @@
-#ifndef CMARK_MAP_H
-#define CMARK_MAP_H
-
-#include "chunk.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct cmark_map_entry {
-  struct cmark_map_entry *next;
-  unsigned char *label;
-  size_t age;
-  size_t size;
-};
-
-typedef struct cmark_map_entry cmark_map_entry;
-
-struct cmark_map;
-
-typedef void (*cmark_map_free_f)(struct cmark_map *, cmark_map_entry *);
-
-struct cmark_map {
-  cmark_mem *mem;
-  cmark_map_entry *refs;
-  cmark_map_entry **sorted;
-  size_t size;
-  size_t ref_size;
-  size_t max_ref_size;
-  cmark_map_free_f free;
-};
-
-typedef struct cmark_map cmark_map;
-
-unsigned char *normalize_map_label(cmark_mem *mem, cmark_chunk *ref);
-cmark_map *cmark_map_new(cmark_mem *mem, cmark_map_free_f free);
-void cmark_map_free(cmark_map *map);
-cmark_map_entry *cmark_map_lookup(cmark_map *map, cmark_chunk *label);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif