redcarpet 3.0.0 → 3.1.0

data/ext/redcarpet/html.h

@@ -14,8 +14,8 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#ifndef UPSKIRT_HTML_H
-#define UPSKIRT_HTML_H
+#ifndef HTML_H__
+#define HTML_H__
 
 #include "markdown.h"
 #include "buffer.h"
@@ -27,9 +27,9 @@ extern "C" {
 
 struct html_renderopt {
 	struct {
-		int header_count;
 		int current_level;
 		int level_offset;
+		int nesting_level;
 	} toc_data;
 
 	unsigned int flags;
@@ -65,7 +65,7 @@ extern void
 sdhtml_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options_ptr, unsigned int render_flags);
 
 extern void
-sdhtml_toc_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options_ptr);
+sdhtml_toc_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options_ptr, int nesting_level);
 
 extern void
 sdhtml_smartypants(struct buf *ob, const uint8_t *text, size_t size);

data/ext/redcarpet/markdown.c

@@ -55,6 +55,29 @@ struct link_ref {
 	struct link_ref *next;
 };
 
+/* footnote_ref: reference to a footnote */
+struct footnote_ref {
+	unsigned int id;
+
+	int is_used;
+	unsigned int num;
+
+	struct buf *contents;
+};
+
+/* footnote_item: an item in a footnote_list */
+struct footnote_item {
+	struct footnote_ref *ref;
+	struct footnote_item *next;
+};
+
+/* footnote_list: linked list of footnote_item */
+struct footnote_list {
+	unsigned int count;
+	struct footnote_item *head;
+	struct footnote_item *tail;
+};
+
 /* char_trigger: function pointer to render active chars */
 /*   returns the number of chars taken care of */
 /*   data is the pointer of the beginning of the span */
@@ -66,6 +89,7 @@ typedef size_t
 static size_t char_emphasis(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
 static size_t char_underline(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
 static size_t char_highlight(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_quote(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
 static size_t char_linebreak(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
 static size_t char_codespan(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
 static size_t char_escape(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
@@ -90,6 +114,7 @@ enum markdown_char_t {
 	MD_CHAR_AUTOLINK_EMAIL,
 	MD_CHAR_AUTOLINK_WWW,
 	MD_CHAR_SUPERSCRIPT,
+	MD_CHAR_QUOTE
 };
 
 static char_trigger markdown_char_ptrs[] = {
@@ -105,6 +130,7 @@ static char_trigger markdown_char_ptrs[] = {
 	&char_autolink_email,
 	&char_autolink_www,
 	&char_superscript,
+	&char_quote
 };
 
 /* render • structure containing one particular render */
@@ -113,6 +139,8 @@ struct sd_markdown {
 	void *opaque;
 
 	struct link_ref *refs[REF_TABLE_SIZE];
+	struct footnote_list footnotes_found;
+	struct footnote_list footnotes_used;
 	uint8_t active_char[256];
 	struct stack work_bufs[2];
 	unsigned int ext_flags;
@@ -235,6 +263,77 @@ free_link_refs(struct link_ref **references)
 	}
 }
 
+static struct footnote_ref *
+create_footnote_ref(struct footnote_list *list, const uint8_t *name, size_t name_size)
+{
+	struct footnote_ref *ref = calloc(1, sizeof(struct footnote_ref));
+	if (!ref)
+		return NULL;
+
+	ref->id = hash_link_ref(name, name_size);
+
+	return ref;
+}
+
+static int
+add_footnote_ref(struct footnote_list *list, struct footnote_ref *ref)
+{
+	struct footnote_item *item = calloc(1, sizeof(struct footnote_item));
+	if (!item)
+		return 0;
+	item->ref = ref;
+
+	if (list->head == NULL) {
+		list->head = list->tail = item;
+	} else {
+		list->tail->next = item;
+		list->tail = item;
+	}
+	list->count++;
+
+	return 1;
+}
+
+static struct footnote_ref *
+find_footnote_ref(struct footnote_list *list, uint8_t *name, size_t length)
+{
+	unsigned int hash = hash_link_ref(name, length);
+	struct footnote_item *item = NULL;
+
+	item = list->head;
+
+	while (item != NULL) {
+		if (item->ref->id == hash)
+			return item->ref;
+		item = item->next;
+	}
+
+	return NULL;
+}
+
+static void
+free_footnote_ref(struct footnote_ref *ref)
+{
+	bufrelease(ref->contents);
+	free(ref);
+}
+
+static void
+free_footnote_list(struct footnote_list *list, int free_refs)
+{
+	struct footnote_item *item = list->head;
+	struct footnote_item *next;
+
+	while (item) {
+		next = item->next;
+		if (free_refs)
+			free_footnote_ref(item->ref);
+		free(item);
+		item = next;
+	}
+}
+
+
 /*
  * Check whether a char is a Markdown space.
 
@@ -691,6 +790,48 @@ char_codespan(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t of
 	return end;
 }
 
+/* char_quote • '"' parsing a quote */
+static size_t
+char_quote(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+{
+	size_t end, nq = 0, i, f_begin, f_end;
+
+	/* counting the number of quotes in the delimiter */
+	while (nq < size && data[nq] == '"')
+		nq++;
+
+	/* finding the next delimiter */
+	i = 0;
+	for (end = nq; end < size && i < nq; end++) {
+		if (data[end] == '"') i++;
+		else i = 0;
+	}
+
+	if (i < nq && end >= size)
+		return 0; /* no matching delimiter */
+
+	/* trimming outside whitespaces */
+	f_begin = nq;
+	while (f_begin < end && data[f_begin] == ' ')
+		f_begin++;
+
+	f_end = end - nq;
+	while (f_end > nq && data[f_end-1] == ' ')
+		f_end--;
+
+	/* real quote */
+	if (f_begin < f_end) {
+		struct buf work = { data + f_begin, f_end - f_begin, 0, 0 };
+		if (!rndr->cb.quote(ob, &work, rndr->opaque))
+			end = 0;
+	} else {
+		if (!rndr->cb.quote(ob, 0, rndr->opaque))
+			end = 0;
+	}
+
+	return end;
+}
+
 
 /* char_escape • '\\' backslash escape */
 static size_t
@@ -834,7 +975,7 @@ char_autolink_url(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_
 
 	link = rndr_newbuf(rndr, BUFFER_SPAN);
 
-	if ((link_len = sd_autolink__url(&rewind, link, data, offset, size, 0)) > 0) {
+	if ((link_len = sd_autolink__url(&rewind, link, data, offset, size, SD_AUTOLINK_SHORT_DOMAINS)) > 0) {
 		ob->size -= rewind;
 		rndr->cb.autolink(ob, link, MKDA_NORMAL, rndr->opaque);
 	}
@@ -885,6 +1026,34 @@ char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset
 	txt_e = i;
 	i++;
 
+	/* footnote link */
+	if (rndr->ext_flags & MKDEXT_FOOTNOTES && data[1] == '^') {
+		if (txt_e < 3)
+			goto cleanup;
+
+		struct buf id = { 0, 0, 0, 0 };
+		struct footnote_ref *fr;
+
+		id.data = data + 2;
+		id.size = txt_e - 2;
+
+		fr = find_footnote_ref(&rndr->footnotes_found, id.data, id.size);
+
+		/* mark footnote used */
+		if (fr && !fr->is_used) {
+			if(!add_footnote_ref(&rndr->footnotes_used, fr))
+				goto cleanup;
+			fr->is_used = 1;
+			fr->num = rndr->footnotes_used.count;
+		}
+
+		/* render */
+		if (fr && rndr->cb.footnote_ref)
+				ret = rndr->cb.footnote_ref(ob, fr->num, rndr->opaque);
+
+		goto cleanup;
+	}
+
 	/* skip any amount of whitespace or newline */
 	/* (this is much more laxist than original markdown syntax) */
 	while (i < size && _isspace(data[i]))
@@ -1131,7 +1300,7 @@ char_superscript(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 
 /* is_empty • returns the line length when it is empty, 0 otherwise */
 static size_t
-is_empty(uint8_t *data, size_t size)
+is_empty(const uint8_t *data, size_t size)
 {
 	size_t i;
 
@@ -1475,7 +1644,7 @@ parse_paragraph(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 		 * let's check to see if there's some kind of block starting
 		 * here
 		 */
-		if ((rndr->ext_flags & MKDEXT_LAX_SPACING) && !isalnum(data[i])) {
+		if ((rndr->ext_flags & MKDEXT_LAX_SPACING) && !isalpha(data[i])) {
 			if (prefix_oli(data + i, size - i) ||
 				prefix_uli(data + i, size - i)) {
 				end = i;
@@ -1543,7 +1712,7 @@ parse_paragraph(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 		parse_inline(header_work, rndr, work.data, work.size);
 
 		if (rndr->cb.header)
-			rndr->cb.header(ob, header_work, (int)level, rndr->opaque);
+			rndr->cb.header(ob, header_work, (int)level, header_anchor(header_work), rndr->opaque);
 
 		rndr_popbuf(rndr, BUFFER_SPAN);
 	}
@@ -1724,10 +1893,8 @@ parse_listitem(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t s
 			if (!sublist)
 				sublist = work->size;
 		}
-		/* joining only indented stuff after empty lines;
-		 * note that now we only require 1 space of indentation
-		 * to continue a list */
-		else if (in_empty && pre == 0) {
+		/* joining only indented stuff after empty lines */
+		else if (in_empty && i < 4 && data[beg] != '\t') {
 			*flags |= MKD_LI_END;
 			break;
 		}
@@ -1825,7 +1992,7 @@ parse_atxheader(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 		parse_inline(work, rndr, data + i, end - i);
 
 		if (rndr->cb.header)
-			rndr->cb.header(ob, work, (int)level, rndr->opaque);
+			rndr->cb.header(ob, work, (int)level, header_anchor(work), rndr->opaque);
 
 		rndr_popbuf(rndr, BUFFER_SPAN);
 	}
@@ -1833,6 +2000,44 @@ parse_atxheader(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 	return skip;
 }
 
+/* parse_footnote_def • parse a single footnote definition */
+static void
+parse_footnote_def(struct buf *ob, struct sd_markdown *rndr, unsigned int num, uint8_t *data, size_t size)
+{
+	struct buf *work = 0;
+	work = rndr_newbuf(rndr, BUFFER_SPAN);
+
+	parse_block(work, rndr, data, size);
+
+	if (rndr->cb.footnote_def)
+	rndr->cb.footnote_def(ob, work, num, rndr->opaque);
+	rndr_popbuf(rndr, BUFFER_SPAN);
+}
+
+/* parse_footnote_list • render the contents of the footnotes */
+static void
+parse_footnote_list(struct buf *ob, struct sd_markdown *rndr, struct footnote_list *footnotes)
+{
+	struct buf *work = 0;
+	struct footnote_item *item;
+	struct footnote_ref *ref;
+
+	if (footnotes->count == 0)
+		return;
+
+	work = rndr_newbuf(rndr, BUFFER_BLOCK);
+
+	item = footnotes->head;
+	while (item) {
+		ref = item->ref;
+		parse_footnote_def(work, rndr, ref->num, ref->contents->data, ref->contents->size);
+		item = item->next;
+	}
+
+	if (rndr->cb.footnotes)
+		rndr->cb.footnotes(ob, work, rndr->opaque);
+	rndr_popbuf(rndr, BUFFER_BLOCK);
+}
 
 /* htmlblock_end • checking end of HTML block : </tag>[ \t]*\n[ \t*]\n */
 /*	returns the length on match, 0 otherwise */
@@ -2264,6 +2469,111 @@ parse_block(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size
  * REFERENCE PARSING *
  *********************/
 
+/* is_footnote • returns whether a line is a footnote definition or not */
+static int
+is_footnote(const uint8_t *data, size_t beg, size_t end, size_t *last, struct footnote_list *list)
+{
+	size_t i = 0;
+	struct buf *contents = 0;
+	size_t ind = 0;
+	int in_empty = 0;
+	size_t start = 0;
+
+	size_t id_offset, id_end;
+
+	/* up to 3 optional leading spaces */
+	if (beg + 3 >= end) return 0;
+	if (data[beg] == ' ') { i = 1;
+	if (data[beg + 1] == ' ') { i = 2;
+	if (data[beg + 2] == ' ') { i = 3;
+	if (data[beg + 3] == ' ') return 0; } } }
+	i += beg;
+
+	/* id part: caret followed by anything between brackets */
+	if (data[i] != '[') return 0;
+	i++;
+	if (i >= end || data[i] != '^') return 0;
+	i++;
+	id_offset = i;
+	while (i < end && data[i] != '\n' && data[i] != '\r' && data[i] != ']')
+		i++;
+	if (i >= end || data[i] != ']') return 0;
+	id_end = i;
+
+	/* spacer: colon (space | tab)* newline? (space | tab)* */
+	i++;
+	if (i >= end || data[i] != ':') return 0;
+	i++;
+
+	/* getting content buffer */
+	contents = bufnew(64);
+
+	start = i;
+
+	/* process lines similiar to a list item */
+	while (i < end) {
+		while (i < end && data[i] != '\n' && data[i] != '\r') i++;
+
+		/* process an empty line */
+		if (is_empty(data + start, i - start)) {
+			in_empty = 1;
+			if (i < end && (data[i] == '\n' || data[i] == '\r')) {
+				i++;
+				if (i < end && data[i] == '\n' && data[i - 1] == '\r') i++;
+			}
+			start = i;
+			continue;
+		}
+
+		/* calculating the indentation */
+		ind = 0;
+		while (ind < 4 && start + ind < end && data[start + ind] == ' ')
+			ind++;
+
+		/* joining only indented stuff after empty lines;
+		 * note that now we only require 1 space of indentation
+		 * to continue, just like lists */
+		if (ind == 0) {
+			if (start == id_end + 2 && data[start] == '\t') {}
+			else break;
+		}
+		else if (in_empty) {
+			bufputc(contents, '\n');
+		}
+
+		in_empty = 0;
+
+		/* adding the line into the content buffer */
+		bufput(contents, data + start + ind, i - start - ind);
+		/* add carriage return */
+		if (i < end) {
+			bufput(contents, "\n", 1);
+			if (i < end && (data[i] == '\n' || data[i] == '\r')) {
+				i++;
+				if (i < end && data[i] == '\n' && data[i - 1] == '\r') i++;
+			}
+		}
+		start = i;
+	}
+
+	if (last)
+		*last = start;
+
+	if (list) {
+		struct footnote_ref *ref;
+		ref = create_footnote_ref(list, data + id_offset, id_end - id_offset);
+		if (!ref)
+			return 0;
+		if (!add_footnote_ref(list, ref)) {
+			free_footnote_ref(ref);
+			return 0;
+		}
+		ref->contents = contents;
+	}
+
+	return 1;
+}
+
 /* is_ref • returns whether a line is a reference or not */
 static int
 is_ref(const uint8_t *data, size_t beg, size_t end, size_t *last, struct link_ref **refs)
@@ -2296,11 +2606,11 @@ is_ref(const uint8_t *data, size_t beg, size_t end, size_t *last, struct link_re
 	i++;
 	if (i >= end || data[i] != ':') return 0;
 	i++;
-	while (i < end && data[i] == ' ') i++;
+	while (i < end && strchr("\t ", data[i])) i++;
 	if (i < end && (data[i] == '\n' || data[i] == '\r')) {
 		i++;
 		if (i < end && data[i] == '\r' && data[i - 1] == '\n') i++; }
-	while (i < end && data[i] == ' ') i++;
+	while (i < end && strchr("\t ", data[i])) i++;
 	if (i >= end) return 0;
 
 	/* link: whitespace-free sequence, optionally between angle brackets */
@@ -2316,7 +2626,7 @@ is_ref(const uint8_t *data, size_t beg, size_t end, size_t *last, struct link_re
 	else link_end = i;
 
 	/* optional spacer: (space | tab)* (newline | '\'' | '"' | '(' ) */
-	while (i < end && data[i] == ' ') i++;
+	while (i < end && strchr("\t ", data[i])) i++;
 	if (i < end && data[i] != '\n' && data[i] != '\r'
 			&& data[i] != '\'' && data[i] != '"' && data[i] != '(')
 		return 0;
@@ -2329,7 +2639,7 @@ is_ref(const uint8_t *data, size_t beg, size_t end, size_t *last, struct link_re
 	/* optional (space|tab)* spacer after a newline */
 	if (line_end) {
 		i = line_end + 1;
-		while (i < end && data[i] == ' ') i++; }
+		while (i < end && strchr("\t ", data[i])) i++; }
 
 	/* optional title: any non-newline sequence enclosed in '"()
 					alone on its line */
@@ -2460,6 +2770,9 @@ sd_markdown_new(
 	if (extensions & MKDEXT_SUPERSCRIPT)
 		md->active_char['^'] = MD_CHAR_SUPERSCRIPT;
 
+	if (extensions & MKDEXT_QUOTE)
+		md->active_char['"'] = MD_CHAR_QUOTE;
+
 	/* Extension data */
 	md->ext_flags = extensions;
 	md->opaque = opaque;
@@ -2488,6 +2801,14 @@ sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, str
 	/* reset the references table */
 	memset(&md->refs, 0x0, REF_TABLE_SIZE * sizeof(void *));
 
+	int footnotes_enabled = md->ext_flags & MKDEXT_FOOTNOTES;
+
+	/* reset the footnotes lists */
+	if (footnotes_enabled) {
+		memset(&md->footnotes_found, 0x0, sizeof(md->footnotes_found));
+		memset(&md->footnotes_used, 0x0, sizeof(md->footnotes_used));
+	}
+
 	/* first pass: looking for references, copying everything else */
 	beg = 0;
 
@@ -2497,7 +2818,9 @@ sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, str
 		beg += 3;
 
 	while (beg < doc_size) /* iterating over lines */
-		if (is_ref(document, beg, doc_size, &end, md->refs))
+		if (footnotes_enabled && is_footnote(document, beg, doc_size, &end, &md->footnotes_found))
+			beg = end;
+		else if (is_ref(document, beg, doc_size, &end, md->refs))
 			beg = end;
 		else { /* skipping to the next line */
 			end = beg;
@@ -2533,12 +2856,20 @@ sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, str
 		parse_block(ob, md, text->data, text->size);
 	}
 
+	/* footnotes */
+	if (footnotes_enabled)
+		parse_footnote_list(ob, md, &md->footnotes_used);
+
 	if (md->cb.doc_footer)
 		md->cb.doc_footer(ob, md->opaque);
 
 	/* clean-up */
 	bufrelease(text);
 	free_link_refs(md->refs);
+	if (footnotes_enabled) {
+		free_footnote_list(&md->footnotes_found, 1);
+		free_footnote_list(&md->footnotes_used, 0);
+	}
 
 	assert(md->work_bufs[BUFFER_SPAN].size == 0);
 	assert(md->work_bufs[BUFFER_BLOCK].size == 0);
@@ -2560,11 +2891,3 @@ sd_markdown_free(struct sd_markdown *md)
 
 	free(md);
 }
-
-void
-sd_version(int *ver_major, int *ver_minor, int *ver_revision)
-{
-	*ver_major = SUNDOWN_VER_MAJOR;
-	*ver_minor = SUNDOWN_VER_MINOR;
-	*ver_revision = SUNDOWN_VER_REVISION;
-}