apex-ruby 1.0.6

data/ext/apex_ext/apex_src/vendor/cmark-gfm/src/linked_list.c

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

data/ext/apex_ext/apex_src/vendor/cmark-gfm/src/main.c

@@ -0,0 +1,328 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include "config.h"
+#include "cmark-gfm.h"
+#include "node.h"
+#include "cmark-gfm-extension_api.h"
+#include "syntax_extension.h"
+#include "parser.h"
+#include "registry.h"
+
+#include "../extensions/cmark-gfm-core-extensions.h"
+
+#if defined(__OpenBSD__)
+#  include <sys/param.h>
+#  if OpenBSD >= 201605
+#    define USE_PLEDGE
+#    include <unistd.h>
+#  endif
+#endif
+
+#if defined(__OpenBSD__)
+#  include <sys/param.h>
+#  if OpenBSD >= 201605
+#    define USE_PLEDGE
+#    include <unistd.h>
+#  endif
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+typedef enum {
+  FORMAT_NONE,
+  FORMAT_HTML,
+  FORMAT_XML,
+  FORMAT_MAN,
+  FORMAT_COMMONMARK,
+  FORMAT_PLAINTEXT,
+  FORMAT_LATEX
+} writer_format;
+
+void print_usage() {
+  printf("Usage:   cmark-gfm [FILE*]\n");
+  printf("Options:\n");
+  printf("  --to, -t FORMAT   Specify output format (html, xml, man, "
+         "commonmark, plaintext, latex)\n");
+  printf("  --width WIDTH     Specify wrap width (default 0 = nowrap)\n");
+  printf("  --sourcepos       Include source position attribute\n");
+  printf("  --hardbreaks      Treat newlines as hard line breaks\n");
+  printf("  --nobreaks        Render soft line breaks as spaces\n");
+  printf("  --unsafe          Render raw HTML and dangerous URLs\n");
+  printf("  --smart           Use smart punctuation\n");
+  printf("  --validate-utf8   Replace UTF-8 invalid sequences with U+FFFD\n");
+  printf("  --github-pre-lang Use GitHub-style <pre lang> for code blocks\n");
+  printf("  --extension, -e EXTENSION_NAME  Specify an extension name to use\n");
+  printf("  --list-extensions               List available extensions and quit\n");
+  printf("  --strikethrough-double-tilde    Only parse strikethrough (if enabled)\n");
+  printf("                                  with two tildes\n");
+  printf("  --table-prefer-style-attributes Use style attributes to align table cells\n"
+         "                                  instead of align attributes.\n");
+  printf("  --full-info-string              Include remainder of code block info\n"
+         "                                  string in a separate attribute.\n");
+  printf("  --help, -h       Print usage information\n");
+  printf("  --version        Print version\n");
+}
+
+static bool print_document(cmark_node *document, writer_format writer,
+                           int options, int width, cmark_parser *parser) {
+  char *result;
+
+  cmark_mem *mem = cmark_get_default_mem_allocator();
+
+  switch (writer) {
+  case FORMAT_HTML:
+    result = cmark_render_html_with_mem(document, options, parser->syntax_extensions, mem);
+    break;
+  case FORMAT_XML:
+    result = cmark_render_xml_with_mem(document, options, mem);
+    break;
+  case FORMAT_MAN:
+    result = cmark_render_man_with_mem(document, options, width, mem);
+    break;
+  case FORMAT_COMMONMARK:
+    result = cmark_render_commonmark_with_mem(document, options, width, mem);
+    break;
+  case FORMAT_PLAINTEXT:
+    result = cmark_render_plaintext_with_mem(document, options, width, mem);
+    break;
+  case FORMAT_LATEX:
+    result = cmark_render_latex_with_mem(document, options, width, mem);
+    break;
+  default:
+    fprintf(stderr, "Unknown format %d\n", writer);
+    return false;
+  }
+  printf("%s", result);
+  mem->free(result);
+
+  return true;
+}
+
+static void print_extensions(void) {
+  cmark_llist *syntax_extensions;
+  cmark_llist *tmp;
+
+  printf ("Available extensions:\nfootnotes\n");
+
+  cmark_mem *mem = cmark_get_default_mem_allocator();
+  syntax_extensions = cmark_list_syntax_extensions(mem);
+  for (tmp = syntax_extensions; tmp; tmp=tmp->next) {
+    cmark_syntax_extension *ext = (cmark_syntax_extension *) tmp->data;
+    printf("%s\n", ext->name);
+  }
+
+  cmark_llist_free(mem, syntax_extensions);
+}
+
+int main(int argc, char *argv[]) {
+  int i, numfps = 0;
+  int *files;
+  char buffer[4096];
+  cmark_parser *parser = NULL;
+  size_t bytes;
+  cmark_node *document = NULL;
+  int width = 0;
+  char *unparsed;
+  writer_format writer = FORMAT_HTML;
+  int options = CMARK_OPT_DEFAULT;
+  int res = 1;
+
+#ifdef USE_PLEDGE
+  if (pledge("stdio rpath", NULL) != 0) {
+    perror("pledge");
+    return 1;
+  }
+#endif
+
+  cmark_gfm_core_extensions_ensure_registered();
+
+#ifdef USE_PLEDGE
+  if (pledge("stdio rpath", NULL) != 0) {
+    perror("pledge");
+    return 1;
+  }
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  _setmode(_fileno(stdin), _O_BINARY);
+  _setmode(_fileno(stdout), _O_BINARY);
+#endif
+
+  files = (int *)calloc(argc, sizeof(*files));
+
+  for (i = 1; i < argc; i++) {
+    if (strcmp(argv[i], "--version") == 0) {
+      printf("cmark-gfm %s", CMARK_GFM_VERSION_STRING);
+      printf(" - CommonMark with GitHub Flavored Markdown converter\n(C) 2014-2016 John MacFarlane\n");
+      goto success;
+    } else if (strcmp(argv[i], "--list-extensions") == 0) {
+      print_extensions();
+      goto success;
+    } else if (strcmp(argv[i], "--full-info-string") == 0) {
+      options |= CMARK_OPT_FULL_INFO_STRING;
+    } else if (strcmp(argv[i], "--table-prefer-style-attributes") == 0) {
+      options |= CMARK_OPT_TABLE_PREFER_STYLE_ATTRIBUTES;
+    } else if (strcmp(argv[i], "--strikethrough-double-tilde") == 0) {
+      options |= CMARK_OPT_STRIKETHROUGH_DOUBLE_TILDE;
+    } else if (strcmp(argv[i], "--sourcepos") == 0) {
+      options |= CMARK_OPT_SOURCEPOS;
+    } else if (strcmp(argv[i], "--hardbreaks") == 0) {
+      options |= CMARK_OPT_HARDBREAKS;
+    } else if (strcmp(argv[i], "--nobreaks") == 0) {
+      options |= CMARK_OPT_NOBREAKS;
+    } else if (strcmp(argv[i], "--smart") == 0) {
+      options |= CMARK_OPT_SMART;
+    } else if (strcmp(argv[i], "--github-pre-lang") == 0) {
+      options |= CMARK_OPT_GITHUB_PRE_LANG;
+    } else if (strcmp(argv[i], "--unsafe") == 0) {
+      options |= CMARK_OPT_UNSAFE;
+    } else if (strcmp(argv[i], "--validate-utf8") == 0) {
+      options |= CMARK_OPT_VALIDATE_UTF8;
+    } else if (strcmp(argv[i], "--liberal-html-tag") == 0) {
+      options |= CMARK_OPT_LIBERAL_HTML_TAG;
+    } else if ((strcmp(argv[i], "--help") == 0) ||
+               (strcmp(argv[i], "-h") == 0)) {
+      print_usage();
+      goto success;
+    } else if (strcmp(argv[i], "--width") == 0) {
+      i += 1;
+      if (i < argc) {
+        width = (int)strtol(argv[i], &unparsed, 10);
+        if (unparsed && strlen(unparsed) > 0) {
+          fprintf(stderr, "failed parsing width '%s' at '%s'\n", argv[i],
+                  unparsed);
+          goto failure;
+        }
+      } else {
+        fprintf(stderr, "--width requires an argument\n");
+        goto failure;
+      }
+    } else if ((strcmp(argv[i], "-t") == 0) || (strcmp(argv[i], "--to") == 0)) {
+      i += 1;
+      if (i < argc) {
+        if (strcmp(argv[i], "man") == 0) {
+          writer = FORMAT_MAN;
+        } else if (strcmp(argv[i], "html") == 0) {
+          writer = FORMAT_HTML;
+        } else if (strcmp(argv[i], "xml") == 0) {
+          writer = FORMAT_XML;
+        } else if (strcmp(argv[i], "commonmark") == 0) {
+          writer = FORMAT_COMMONMARK;
+        } else if (strcmp(argv[i], "plaintext") == 0) {
+          writer = FORMAT_PLAINTEXT;
+        } else if (strcmp(argv[i], "latex") == 0) {
+          writer = FORMAT_LATEX;
+        } else {
+          fprintf(stderr, "Unknown format %s\n", argv[i]);
+          goto failure;
+        }
+      } else {
+        fprintf(stderr, "No argument provided for %s\n", argv[i - 1]);
+        goto failure;
+      }
+    } else if ((strcmp(argv[i], "-e") == 0) || (strcmp(argv[i], "--extension") == 0)) {
+      i += 1; // Simpler to handle extensions in a second pass, as we can directly register
+              // them with the parser.
+
+      if (i < argc && strcmp(argv[i], "footnotes") == 0) {
+        options |= CMARK_OPT_FOOTNOTES;
+      }
+    } else if (*argv[i] == '-') {
+      print_usage();
+      goto failure;
+    } else { // treat as file argument
+      files[numfps++] = i;
+    }
+  }
+
+#if DEBUG
+  parser = cmark_parser_new(options);
+#else
+  parser = cmark_parser_new_with_mem(options, cmark_get_arena_mem_allocator());
+#endif
+
+  for (i = 1; i < argc; i++) {
+    if ((strcmp(argv[i], "-e") == 0) || (strcmp(argv[i], "--extension") == 0)) {
+      i += 1;
+      if (i < argc) {
+        if (strcmp(argv[i], "footnotes") == 0) {
+          continue;
+        }
+        cmark_syntax_extension *syntax_extension = cmark_find_syntax_extension(argv[i]);
+        if (!syntax_extension) {
+          fprintf(stderr, "Unknown extension %s\n", argv[i]);
+          goto failure;
+        }
+        cmark_parser_attach_syntax_extension(parser, syntax_extension);
+      } else {
+        fprintf(stderr, "No argument provided for %s\n", argv[i - 1]);
+        goto failure;
+      }
+    }
+  }
+
+  for (i = 0; i < numfps; i++) {
+    FILE *fp = fopen(argv[files[i]], "rb");
+    if (fp == NULL) {
+      fprintf(stderr, "Error opening file %s: %s\n", argv[files[i]],
+              strerror(errno));
+      goto failure;
+    }
+
+    while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
+      cmark_parser_feed(parser, buffer, bytes);
+      if (bytes < sizeof(buffer)) {
+        break;
+      }
+    }
+
+    fclose(fp);
+  }
+
+  if (numfps == 0) {
+    while ((bytes = fread(buffer, 1, sizeof(buffer), stdin)) > 0) {
+      cmark_parser_feed(parser, buffer, bytes);
+      if (bytes < sizeof(buffer)) {
+        break;
+      }
+    }
+  }
+
+#ifdef USE_PLEDGE
+  if (pledge("stdio", NULL) != 0) {
+    perror("pledge");
+    return 1;
+  }
+#endif
+
+  document = cmark_parser_finish(parser);
+
+  if (!document || !print_document(document, writer, options, width, parser))
+    goto failure;
+
+success:
+  res = 0;
+
+failure:
+
+#if DEBUG
+  if (parser)
+  cmark_parser_free(parser);
+
+  if (document)
+    cmark_node_free(document);
+#else
+  cmark_arena_reset();
+#endif
+
+  cmark_release_plugins();
+
+  free(files);
+
+  return res;
+}

data/ext/apex_ext/apex_src/vendor/cmark-gfm/src/man.c

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