commonmarker 0.0.1

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

@@ -0,0 +1,82 @@
+#ifndef CMARK_NODE_H
+#define CMARK_NODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+
+#include "cmark.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;
+} cmark_list;
+
+typedef struct {
+	cmark_chunk       info;
+	cmark_chunk       literal;
+	int               fence_length;
+	/* fence_offset must be 0-3, so we can use int8_t */
+	int8_t            fence_offset;
+	unsigned char     fence_char;
+	bool              fenced;
+} cmark_code;
+
+typedef struct {
+	int level;
+	bool setext;
+} cmark_header;
+
+typedef struct {
+	unsigned char *url;
+	unsigned char *title;
+} cmark_link;
+
+struct cmark_node {
+	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;
+
+	int start_line;
+	int start_column;
+	int end_line;
+	int end_column;
+
+	cmark_node_type type;
+
+	bool open;
+	bool last_line_blank;
+
+	cmark_strbuf string_content;
+
+	union {
+		cmark_chunk       literal;
+		cmark_list        list;
+		cmark_code        code;
+		cmark_header      header;
+		cmark_link        link;
+	} as;
+};
+
+CMARK_EXPORT int
+cmark_node_check(cmark_node *node, FILE *out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,29 @@
+#ifndef CMARK_AST_H
+#define CMARK_AST_H
+
+#include <stdio.h>
+#include "node.h"
+#include "buffer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MAX_LINK_LABEL_LENGTH 1000
+
+struct cmark_parser {
+	struct cmark_reference_map *refmap;
+	struct cmark_node* root;
+	struct cmark_node* current;
+	int line_number;
+	cmark_strbuf *curline;
+	int last_line_length;
+	cmark_strbuf *linebuf;
+	int options;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,154 @@
+#include "cmark.h"
+#include "utf8.h"
+#include "parser.h"
+#include "references.h"
+#include "inlines.h"
+#include "chunk.h"
+
+static unsigned int
+refhash(const unsigned char *link_ref)
+{
+	unsigned int hash = 0;
+
+	while (*link_ref)
+		hash = (*link_ref++) + (hash << 6) + (hash << 16) - hash;
+
+	return hash;
+}
+
+static void reference_free(cmark_reference *ref)
+{
+	if(ref != NULL) {
+		free(ref->label);
+		free(ref->url);
+		free(ref->title);
+		free(ref);
+	}
+}
+
+// normalize reference:  collapse internal whitespace to single space,
+// remove leading/trailing whitespace, case fold
+// Return NULL if the reference name is actually empty (i.e. composed
+// solely from whitespace)
+static unsigned char *normalize_reference(cmark_chunk *ref)
+{
+	cmark_strbuf normalized = GH_BUF_INIT;
+	unsigned char *result;
+
+	if(ref == NULL)
+		return NULL;
+
+	if (ref->len == 0)
+		return NULL;
+
+	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') {
+		free(result);
+		return NULL;
+	}
+
+	return result;
+}
+
+static void add_reference(cmark_reference_map *map, cmark_reference* ref)
+{
+	cmark_reference *t = ref->next = map->table[ref->hash % REFMAP_SIZE];
+
+	while (t) {
+		if (t->hash == ref->hash &&
+		    !strcmp((char *)t->label, (char *)ref->label)) {
+			reference_free(ref);
+			return;
+		}
+
+		t = t->next;
+	}
+
+	map->table[ref->hash % REFMAP_SIZE] = ref;
+}
+
+void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url,
+                            cmark_chunk *title)
+{
+	cmark_reference *ref;
+	unsigned char *reflabel = normalize_reference(label);
+
+	/* empty reference name, or composed from only whitespace */
+	if (reflabel == NULL)
+		return;
+
+	ref = (cmark_reference *)calloc(1, sizeof(*ref));
+	if(ref != NULL) {
+		ref->label = reflabel;
+		ref->hash = refhash(ref->label);
+		ref->url = cmark_clean_url(url);
+		ref->title = cmark_clean_title(title);
+		ref->next = NULL;
+
+		add_reference(map, ref);
+	}
+}
+
+// Returns reference if refmap contains a reference with matching
+// label, otherwise NULL.
+cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label)
+{
+	cmark_reference *ref = NULL;
+	unsigned char *norm;
+	unsigned int hash;
+
+	if (label->len > MAX_LINK_LABEL_LENGTH)
+		return NULL;
+
+	if (map == NULL)
+		return NULL;
+
+	norm = normalize_reference(label);
+	if (norm == NULL)
+		return NULL;
+
+	hash = refhash(norm);
+	ref = map->table[hash % REFMAP_SIZE];
+
+	while (ref) {
+		if (ref->hash == hash &&
+		    !strcmp((char *)ref->label, (char *)norm))
+			break;
+		ref = ref->next;
+	}
+
+	free(norm);
+	return ref;
+}
+
+void cmark_reference_map_free(cmark_reference_map *map)
+{
+	unsigned int i;
+
+	if(map == NULL)
+		return;
+
+	for (i = 0; i < REFMAP_SIZE; ++i) {
+		cmark_reference *ref = map->table[i];
+		cmark_reference *next;
+
+		while (ref) {
+			next = ref->next;
+			reference_free(ref);
+			ref = next;
+		}
+	}
+
+	free(map);
+}
+
+cmark_reference_map *cmark_reference_map_new(void)
+{
+	return (cmark_reference_map *)calloc(1, sizeof(cmark_reference_map));
+}

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

@@ -0,0 +1,37 @@
+#ifndef CMARK_REFERENCES_H
+#define CMARK_REFERENCES_H
+
+#include "chunk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define REFMAP_SIZE 16
+
+struct cmark_reference {
+	struct cmark_reference *next;
+	unsigned char *label;
+	unsigned char *url;
+	unsigned char *title;
+	unsigned int hash;
+};
+
+typedef struct cmark_reference cmark_reference;
+
+struct cmark_reference_map {
+	cmark_reference *table[REFMAP_SIZE];
+};
+
+typedef struct cmark_reference_map cmark_reference_map;
+
+cmark_reference_map *cmark_reference_map_new(void);
+void cmark_reference_map_free(cmark_reference_map *map);
+cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label);
+extern void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url, cmark_chunk *title);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif