commonmarker 0.0.1

data/ext/commonmarker/cmark/src/inlines.h

@@ -0,0 +1,19 @@
+#ifndef CMARK_INLINES_H
+#define CMARK_INLINES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+unsigned char *cmark_clean_url(cmark_chunk *url);
+unsigned char *cmark_clean_title(cmark_chunk *title);
+
+void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap, int options);
+
+int cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/commonmarker/cmark/src/iterator.c

@@ -0,0 +1,148 @@
+#include <assert.h>
+#include <stdlib.h>
+
+#include "config.h"
+#include "node.h"
+#include "cmark.h"
+#include "iterator.h"
+
+static const int S_leaf_mask =
+    (1 << CMARK_NODE_HTML)        |
+    (1 << CMARK_NODE_HRULE)       |
+    (1 << CMARK_NODE_CODE_BLOCK)  |
+    (1 << CMARK_NODE_TEXT)        |
+    (1 << CMARK_NODE_SOFTBREAK)   |
+    (1 << CMARK_NODE_LINEBREAK)   |
+    (1 << CMARK_NODE_CODE)        |
+    (1 << CMARK_NODE_INLINE_HTML);
+
+cmark_iter*
+cmark_iter_new(cmark_node *root)
+{
+	if (root == NULL) {
+		return NULL;
+	}
+	cmark_iter *iter = (cmark_iter*)malloc(sizeof(cmark_iter));
+	if (iter == NULL) {
+		return NULL;
+	}
+	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)
+{
+	free(iter);
+}
+
+static bool
+S_is_leaf(cmark_node *node)
+{
+	return (1 << node->type) & S_leaf_mask;
+}
+
+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)
+{
+	cmark_iter *iter = cmark_iter_new(root);
+	cmark_strbuf buf = GH_BUF_INIT;
+	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);
+				next = tmp->next;
+				cmark_node_free(tmp);
+				tmp = next;
+			}
+			cmark_strbuf_putc(&buf, 0);
+			cmark_node_set_literal(cur, (char *)buf.ptr);
+		}
+	}
+
+	cmark_strbuf_free(&buf);
+	cmark_iter_free(iter);
+}

data/ext/commonmarker/cmark/src/iterator.h

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

data/ext/commonmarker/cmark/src/libcmark.pc.in

@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_PREFIX@/lib
+includedir=@CMAKE_INSTALL_PREFIX@/include
+
+Name: libcmark
+Description: CommonMark parsing, rendering, and manipulation
+Version: @PROJECT_VERSION@
+Libs: -L${libdir} -lcmark
+Cflags: -I${includedir}

data/ext/commonmarker/cmark/src/main.c

@@ -0,0 +1,191 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include "config.h"
+#include "cmark.h"
+#include "debug.h"
+#include "bench.h"
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+typedef enum {
+	FORMAT_NONE,
+	FORMAT_HTML,
+	FORMAT_XML,
+	FORMAT_MAN,
+	FORMAT_COMMONMARK
+} writer_format;
+
+void print_usage()
+{
+	printf("Usage:   cmark [FILE*]\n");
+	printf("Options:\n");
+	printf("  --to, -t FORMAT  Specify output format (html, xml, man, commonmark)\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("  --smart          Use smart punctuation\n");
+	printf("  --normalize      Consolidate adjacent text nodes\n");
+	printf("  --help, -h       Print usage information\n");
+	printf("  --version        Print version\n");
+}
+
+static void print_document(cmark_node *document, writer_format writer,
+                           int options, int width)
+{
+	char *result;
+
+	switch (writer) {
+	case FORMAT_HTML:
+		result = cmark_render_html(document, options);
+		break;
+	case FORMAT_XML:
+		result = cmark_render_xml(document, options);
+		break;
+	case FORMAT_MAN:
+		result = cmark_render_man(document, options);
+		break;
+	case FORMAT_COMMONMARK:
+		result = cmark_render_commonmark(document, options, width);
+		break;
+	default:
+		fprintf(stderr, "Unknown format %d\n", writer);
+		exit(1);
+	}
+	printf("%s", result);
+	free(result);
+}
+
+int main(int argc, char *argv[])
+{
+	int i, numfps = 0;
+	int *files;
+	char buffer[4096];
+	cmark_parser *parser;
+	size_t bytes;
+	cmark_node *document;
+	int width = 0;
+	char *unparsed;
+	writer_format writer = FORMAT_HTML;
+	int options = CMARK_OPT_DEFAULT;
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+	_setmode(_fileno(stdout), _O_BINARY);
+#endif
+
+	files = (int *)malloc(argc * sizeof(*files));
+
+	for (i = 1; i < argc; i++) {
+		if (strcmp(argv[i], "--version") == 0) {
+			printf("cmark %s", CMARK_VERSION_STRING);
+			printf(" - CommonMark converter\n(C) 2014, 2015 John MacFarlane\n");
+			exit(0);
+		} 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], "--smart") == 0) {
+			options |= CMARK_OPT_SMART;
+		} else if (strcmp(argv[i], "--normalize") == 0) {
+			options |= CMARK_OPT_NORMALIZE;
+		} else if ((strcmp(argv[i], "--help") == 0) ||
+		           (strcmp(argv[i], "-h") == 0)) {
+			print_usage();
+			exit(0);
+		} 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);
+					exit(1);
+				}
+			} else {
+				fprintf(stderr,
+				        "--width requires an argument\n");
+				exit(1);
+			}
+		} 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 {
+					fprintf(stderr,
+					        "Unknown format %s\n", argv[i]);
+					exit(1);
+				}
+			} else {
+				fprintf(stderr, "No argument provided for %s\n",
+				        argv[i - 1]);
+				exit(1);
+			}
+		} else if (*argv[i] == '-') {
+			print_usage();
+			exit(1);
+		} else { // treat as file argument
+			files[numfps++] = i;
+		}
+	}
+
+	parser = cmark_parser_new(options);
+	for (i = 0; i < numfps; i++) {
+		FILE *fp = fopen(argv[files[i]], "r");
+		if (fp == NULL) {
+			fprintf(stderr, "Error opening file %s: %s\n",
+			        argv[files[i]], strerror(errno));
+			exit(1);
+		}
+
+		start_timer();
+		while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
+			cmark_parser_feed(parser, buffer, bytes);
+			if (bytes < sizeof(buffer)) {
+				break;
+			}
+		}
+		end_timer("processing lines");
+
+		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;
+			}
+		}
+	}
+
+	start_timer();
+	document = cmark_parser_finish(parser);
+	end_timer("finishing document");
+	cmark_parser_free(parser);
+
+	start_timer();
+	print_document(document, writer, options, width);
+	end_timer("print_document");
+
+	start_timer();
+	cmark_node_free(document);
+	end_timer("free_blocks");
+
+	free(files);
+
+	return 0;
+}

data/ext/commonmarker/cmark/src/man.c

@@ -0,0 +1,287 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "config.h"
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "utf8.h"
+
+// Functions to convert cmark_nodes to groff man strings.
+
+static void escape_man(cmark_strbuf *dest, const unsigned char *source, int length)
+{
+	int32_t c;
+	int i = 0;
+	int len;
+	bool beginLine = true;
+
+	while (i < length) {
+		len = utf8proc_iterate(source + i, length - i, &c);
+		if (len == -1) { // error condition
+			return;  // return without rendering anything
+		}
+		switch(c) {
+		case 46:
+			if (beginLine) {
+				cmark_strbuf_puts(dest, "\\&.");
+			} else {
+				utf8proc_encode_char(c, dest);
+			}
+			break;
+		case 39:
+			if (beginLine) {
+				cmark_strbuf_puts(dest, "\\&'");
+			} else {
+				utf8proc_encode_char(c, dest);
+			}
+			break;
+		case 45:
+			cmark_strbuf_puts(dest, "\\-");
+			break;
+		case 92:
+			cmark_strbuf_puts(dest, "\\e");
+			break;
+		case 8216: // left single quote
+			cmark_strbuf_puts(dest, "\\[oq]");
+			break;
+		case 8217: // right single quote
+			cmark_strbuf_puts(dest, "\\[cq]");
+			break;
+		case 8220: // left double quote
+			cmark_strbuf_puts(dest, "\\[lq]");
+			break;
+		case 8221: // right double quote
+			cmark_strbuf_puts(dest, "\\[rq]");
+			break;
+		case 8212: // em dash
+			cmark_strbuf_puts(dest, "\\[em]");
+			break;
+		case 8211: // en dash
+			cmark_strbuf_puts(dest, "\\[en]");
+			break;
+		default:
+			utf8proc_encode_char(c, dest);
+		}
+		beginLine = (c == 10);
+		i += len;
+	}
+}
+
+static inline void cr(cmark_strbuf *man)
+{
+	if (man->size && man->ptr[man->size - 1] != '\n')
+		cmark_strbuf_putc(man, '\n');
+}
+
+struct render_state {
+	cmark_strbuf* man;
+	cmark_node *plain;
+};
+
+static int
+S_render_node(cmark_node *node, cmark_event_type ev_type,
+              struct render_state *state)
+{
+	cmark_node *tmp;
+	cmark_strbuf *man = state->man;
+	int list_number;
+	bool entering = (ev_type == CMARK_EVENT_ENTER);
+
+	if (state->plain == node) { // back at original node
+		state->plain = NULL;
+	}
+
+	if (state->plain != NULL) {
+		switch(node->type) {
+		case CMARK_NODE_TEXT:
+		case CMARK_NODE_CODE:
+			escape_man(man, node->as.literal.data,
+			           node->as.literal.len);
+			break;
+
+		case CMARK_NODE_LINEBREAK:
+		case CMARK_NODE_SOFTBREAK:
+			cmark_strbuf_putc(man, ' ');
+			break;
+
+		default:
+			break;
+		}
+		return 1;
+	}
+
+	switch (node->type) {
+	case CMARK_NODE_DOCUMENT:
+		break;
+
+	case CMARK_NODE_BLOCK_QUOTE:
+		if (entering) {
+			cr(man);
+			cmark_strbuf_puts(man, ".RS");
+			cr(man);
+		} else {
+			cr(man);
+			cmark_strbuf_puts(man, ".RE");
+			cr(man);
+		}
+		break;
+
+	case CMARK_NODE_LIST:
+		break;
+
+	case CMARK_NODE_ITEM:
+		if (entering) {
+			cr(man);
+			cmark_strbuf_puts(man, ".IP ");
+			if (cmark_node_get_list_type(node->parent) ==
+			    CMARK_BULLET_LIST) {
+				cmark_strbuf_puts(man, "\\[bu] 2");
+			} else {
+				list_number = cmark_node_get_list_start(node->parent);
+				tmp = node;
+				while (tmp->prev) {
+					tmp = tmp->prev;
+					list_number += 1;
+				}
+				cmark_strbuf_printf(man, "\"%d.\" 4", list_number);
+			}
+			cr(man);
+		} else {
+			cr(man);
+		}
+		break;
+
+	case CMARK_NODE_HEADER:
+		if (entering) {
+			cr(man);
+			cmark_strbuf_puts(man,
+			                  cmark_node_get_header_level(node) == 1 ?
+			                  ".SH" : ".SS");
+			cr(man);
+		} else {
+			cr(man);
+		}
+		break;
+
+	case CMARK_NODE_CODE_BLOCK:
+		cr(man);
+		cmark_strbuf_puts(man, ".IP\n.nf\n\\f[C]\n");
+		escape_man(man, node->as.code.literal.data,
+		           node->as.code.literal.len);
+		cr(man);
+		cmark_strbuf_puts(man, "\\f[]\n.fi");
+		cr(man);
+		break;
+
+	case CMARK_NODE_HTML:
+		break;
+
+	case CMARK_NODE_HRULE:
+		cr(man);
+		cmark_strbuf_puts(man, ".PP\n  *  *  *  *  *");
+		cr(man);
+		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(man);
+				cmark_strbuf_puts(man, ".PP\n");
+			}
+		} else {
+			cr(man);
+		}
+		break;
+
+	case CMARK_NODE_TEXT:
+		escape_man(man, node->as.literal.data,
+		           node->as.literal.len);
+		break;
+
+	case CMARK_NODE_LINEBREAK:
+		cmark_strbuf_puts(man, ".PD 0\n.P\n.PD");
+		cr(man);
+		break;
+
+	case CMARK_NODE_SOFTBREAK:
+		cmark_strbuf_putc(man, '\n');
+		break;
+
+	case CMARK_NODE_CODE:
+		cmark_strbuf_puts(man, "\\f[C]");
+		escape_man(man, node->as.literal.data, node->as.literal.len);
+		cmark_strbuf_puts(man, "\\f[]");
+		break;
+
+	case CMARK_NODE_INLINE_HTML:
+		break;
+
+	case CMARK_NODE_STRONG:
+		if (entering) {
+			cmark_strbuf_puts(man, "\\f[B]");
+		} else {
+			cmark_strbuf_puts(man, "\\f[]");
+		}
+		break;
+
+	case CMARK_NODE_EMPH:
+		if (entering) {
+			cmark_strbuf_puts(man, "\\f[I]");
+		} else {
+			cmark_strbuf_puts(man, "\\f[]");
+		}
+		break;
+
+	case CMARK_NODE_LINK:
+		if (!entering) {
+			cmark_strbuf_printf(man, " (%s)",
+			                    cmark_node_get_url(node));
+		}
+		break;
+
+	case CMARK_NODE_IMAGE:
+		if (entering) {
+			cmark_strbuf_puts(man, "[IMAGE: ");
+			state->plain = node;
+		} else {
+			cmark_strbuf_puts(man, "]");
+		}
+		break;
+
+	default:
+		assert(false);
+		break;
+	}
+
+	// cmark_strbuf_putc(man, 'x');
+	return 1;
+}
+
+char *cmark_render_man(cmark_node *root, int options)
+{
+	char *result;
+	cmark_strbuf man = GH_BUF_INIT;
+	struct render_state state = { &man, NULL };
+	cmark_node *cur;
+	cmark_event_type ev_type;
+	cmark_iter *iter = cmark_iter_new(root);
+
+	if (options == 0) options = 0; // avoid warning about unused parameters
+
+	while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+		cur = cmark_iter_get_node(iter);
+		S_render_node(cur, ev_type, &state);
+	}
+	result = (char *)cmark_strbuf_detach(&man);
+
+	cmark_iter_free(iter);
+	return result;
+}