lounge_lizard 0.1.0

data/ext/drafter/ext/snowcrash/ext/markdown-parser/ext/sundown/src/markdown.h

@@ -0,0 +1,147 @@
+/* markdown.h - generic markdown parser */
+
+/*
+ * Copyright (c) 2009, Natacha Porté
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef UPSKIRT_MARKDOWN_H
+#define UPSKIRT_MARKDOWN_H
+
+#include "buffer.h"
+#include "autolink.h"
+#include "src_map.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SUNDOWN_VERSION "1.16.0"
+#define SUNDOWN_VER_MAJOR 1
+#define SUNDOWN_VER_MINOR 16
+#define SUNDOWN_VER_REVISION 0
+
+/********************
+ * TYPE DEFINITIONS *
+ ********************/
+
+/* mkd_autolink - type of autolink */
+enum mkd_autolink {
+	MKDA_NOT_AUTOLINK,	/* used internally when it is not an autolink*/
+	MKDA_NORMAL,		/* normal http/http/ftp/mailto/etc link */
+	MKDA_EMAIL			/* e-mail link without explit mailto: */
+};
+
+enum mkd_tableflags {
+	MKD_TABLE_ALIGN_L = 1,
+	MKD_TABLE_ALIGN_R = 2,
+	MKD_TABLE_ALIGN_CENTER = 3,
+	MKD_TABLE_ALIGNMASK = 3,
+	MKD_TABLE_HEADER = 4
+};
+
+enum mkd_extensions {
+	MKDEXT_NO_INTRA_EMPHASIS = (1 << 0),
+	MKDEXT_TABLES = (1 << 1),
+	MKDEXT_FENCED_CODE = (1 << 2),
+	MKDEXT_AUTOLINK = (1 << 3),
+	MKDEXT_STRIKETHROUGH = (1 << 4),
+	MKDEXT_SPACE_HEADERS = (1 << 6),
+	MKDEXT_SUPERSCRIPT = (1 << 7),
+	MKDEXT_LAX_SPACING = (1 << 8)
+};
+
+/* sd_callbacks - functions for rendering parsed data */
+struct sd_callbacks {
+	/* block level callbacks - NULL skips the block */
+	void (*blockcode)(struct buf *ob, const struct buf *text, const struct buf *lang, void *opaque);
+	void (*blockquote)(struct buf *ob, const struct buf *text, void *opaque);
+	void (*blockhtml)(struct buf *ob,const  struct buf *text, void *opaque);
+	void (*header)(struct buf *ob, const struct buf *text, int level, void *opaque);
+	void (*hrule)(struct buf *ob, void *opaque);
+	void (*list)(struct buf *ob, const struct buf *text, int flags, void *opaque);
+	void (*listitem)(struct buf *ob, const struct buf *text, int flags, void *opaque);
+	void (*paragraph)(struct buf *ob, const struct buf *text, void *opaque);
+	void (*table)(struct buf *ob, const struct buf *header, const struct buf *body, void *opaque);
+	void (*table_row)(struct buf *ob, const struct buf *text, void *opaque);
+	void (*table_cell)(struct buf *ob, const struct buf *text, int flags, void *opaque);
+
+
+	/* span level callbacks - NULL or return 0 prints the span verbatim */
+	int (*autolink)(struct buf *ob, const struct buf *link, enum mkd_autolink type, void *opaque);
+	int (*codespan)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*double_emphasis)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*emphasis)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*image)(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *alt, void *opaque);
+	int (*linebreak)(struct buf *ob, void *opaque);
+	int (*link)(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque);
+	int (*raw_html_tag)(struct buf *ob, const struct buf *tag, void *opaque);
+	int (*triple_emphasis)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*strikethrough)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*superscript)(struct buf *ob, const struct buf *text, void *opaque);
+
+	/* low level callbacks - NULL copies input directly into the output */
+	void (*entity)(struct buf *ob, const struct buf *entity, void *opaque);
+	void (*normal_text)(struct buf *ob, const struct buf *text, void *opaque);
+
+	/* header and footer */
+	void (*doc_header)(struct buf *ob, void *opaque);
+	void (*doc_footer)(struct buf *ob, void *opaque);
+
+	/* AST construction helpers */
+	void (*blockquote_begin)(void *opaque);
+	void (*list_begin)(int flags, void *opaque);
+	void (*listitem_begin)(int flags, void *opaque);
+    
+    /* source map */
+    void (*block_did_parse)(const src_map* map, const uint8_t *txt_data, size_t size, void *opaque);
+};
+
+struct sd_markdown;
+
+/*********
+ * FLAGS *
+ *********/
+
+/* list/listitem flags */
+#define MKD_LIST_ORDERED	1
+#define MKD_LI_BLOCK		2  /* <li> containing block data */
+
+/**********************
+ * EXPORTED FUNCTIONS *
+ **********************/
+
+extern struct sd_markdown *
+sd_markdown_new(
+	unsigned int extensions,
+	size_t max_nesting,
+	const struct sd_callbacks *callbacks,
+	void *opaque);
+
+extern void
+sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md);
+
+extern void
+sd_markdown_free(struct sd_markdown *md);
+
+extern void
+sd_version(int *major, int *minor, int *revision);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* vim: set filetype=c: */

data/ext/drafter/ext/snowcrash/ext/markdown-parser/ext/sundown/src/src_map.c

@@ -0,0 +1,204 @@
+/*
+ * src_map.c
+ * snowcrash
+ *
+ * Created by Zdenek Nemec on 4/21/13.
+ * Copyright (c) 2013 Apiary Inc. All rights reserved.
+ */
+
+#include "src_map.h"
+
+#include <assert.h>
+
+range *
+range_new(size_t loc, size_t len)
+{
+    range *r;
+    if((r = malloc(sizeof *r)) != NULL) {
+        r->loc = loc;
+        r->len = len;
+    }
+    
+    return r;
+}
+
+void
+range_release(range *r)
+{
+    if (!r)
+        return;
+    
+    free(r);
+    r = NULL;
+}
+
+src_map *
+src_map_new()
+{
+    src_map *map;
+    if ((map = malloc(sizeof *map)) != NULL) {
+        stack_init(map, 4);
+    }
+    
+    return map;
+}
+
+void
+src_map_release(src_map *map)
+{
+    size_t i = 0;
+
+    if (!map)
+        return;
+    
+	for (i = 0; i < (size_t)map->asize; ++i) {
+		range_release(map->item[i]);
+    }
+    
+    stack_free(map);
+    free(map);
+    map = NULL;
+}
+
+src_map *
+src_map_new_submap(const src_map *map, const range *r)
+{
+    size_t i;
+    size_t first_item = -1;
+    src_map *new_map = NULL;
+    size_t remain_len = 0;
+    
+    if (!map ||
+        !map->size ||
+        !r ||
+        !r->len)
+        return NULL;
+
+    /* find first item */
+	for (i = 0; i < (size_t)map->size; ++i) {
+        
+        range *it = (range *)map->item[i];
+        if (r->loc >= it->loc &&
+            r->loc < it->loc + it->len) {
+            first_item = i;
+            break;
+        }
+    }
+    
+    if (first_item == (size_t)-1)
+        return NULL;
+    
+    /* create new map */
+    new_map = src_map_new();
+    remain_len = r->len;
+    
+	for (i = first_item; i < (size_t)map->size; ++i) {
+
+        range *it = (range *)map->item[i];
+        size_t add_loc = (i == first_item) ? r->loc : it->loc;
+        size_t add_len = (it->len < remain_len) ? it->len : remain_len;
+        
+        range *add_range = range_new(add_loc, add_len);
+        stack_push(new_map, add_range);
+        
+        remain_len -= add_len;
+        
+        if (remain_len <= 0)
+            break;
+    }
+
+    return new_map;
+}
+
+/* append range to src_map */
+void
+src_map_append(src_map *map, const range *r)
+{
+    range *new_range = NULL;
+    
+    if (!map ||
+        !r ||
+        !r->len)
+        return;
+    
+    if (map->size) {
+        /* check continuous range */
+        range *last_range = (range *)map->item[map->size - 1];
+        if (r->loc <= last_range->loc + last_range->len) {
+            last_range->len += r->len - (last_range->loc + last_range->len - r->loc);
+            return;
+        }
+    }
+
+    /* not continuous, create new range and push */
+    new_range = range_new(r->loc, r->len);
+    stack_push(map, new_range);
+}
+
+/* return index-th cursor from map */
+size_t
+src_map_location(const src_map *map, size_t index)
+{
+    size_t i = 0;
+    size_t cur = 0;
+    
+    if (!map ||
+        !map->size)
+        return -1;
+    
+	for (i = 0; i < (size_t)map->size; ++i) {
+
+        range *it = (range *)map->item[i];
+        if (index < cur + it->len) {
+            return it->loc + index - cur;
+        }
+        cur += it->len;
+    }
+
+ 	assert(0);
+    return -1;
+}
+
+/* create new src_map from index onward */
+src_map *
+src_map_new_tail(const src_map *map, size_t index, size_t maxlen)
+{
+    size_t i = 0;
+    size_t cur = 0;
+    size_t first_item = -1;
+    size_t count = 0;
+    src_map *new_map = NULL;
+    
+    if (!map ||
+        !map->size)
+        return NULL;
+    
+	for (i = 0; i < (size_t)map->size; ++i) {
+        
+        range *it = (range *)map->item[i];
+        if (index < cur + it->len) {
+            first_item = i;
+            break;
+        }
+        cur += it->len;
+    }
+
+    if (first_item == (size_t)-1)
+        return NULL;
+    
+    /* create new map */
+    new_map = src_map_new();
+	for (i = first_item; i < map->size && count < maxlen; ++i) {
+
+        range *it = (range *)map->item[i];
+        range *add_range = range_new(it->loc, it->len);
+        
+        if (count + it->len > maxlen) {
+            add_range->len = maxlen - count;
+        }
+        count += it->len;
+        stack_push(new_map, add_range);   
+    }
+    
+    return new_map;
+}

data/ext/drafter/ext/snowcrash/ext/markdown-parser/ext/sundown/src/src_map.h

@@ -0,0 +1,58 @@
+/*
+ * src_map.h
+ * snowcrash
+ *
+ * Created by Zdenek Nemec on 4/21/13.
+ * Copyright (c) 2013 Apiary Inc. All rights reserved.
+ *
+ */
+
+#ifndef SNOWCRASH_SUNDOWN_SRCMAP_H
+#define SNOWCRASH_SUNDOWN_SRCMAP_H
+
+#include <stdlib.h>
+#include "stack.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+/* range: character data range */
+typedef struct {
+    size_t loc;
+    size_t len;
+} range;
+
+/* range_new: allocate & init new range */
+range *range_new(size_t loc, size_t len);
+
+/* range_new: release range */
+void range_release(range *r);
+
+/* stack of range forming the buffer content */
+typedef struct stack src_map;
+
+/* src_map_new: allocate new source map */
+src_map *src_map_new();
+    
+/* src_map_release: release source map */
+void src_map_release(src_map *map);
+    
+/* src_map_submap: create map from a subset of map */
+src_map *src_map_new_submap(const src_map *map, const range *r);
+
+/* src_map_new_tail: create map from tail of map */
+src_map *src_map_new_tail(const src_map *map, size_t index, size_t maxlen);
+    
+/* src_map_append: append range to source map */
+void src_map_append(src_map *map, const range *r);
+    
+/* src_map_location: returns location in source for given index */
+size_t src_map_location(const src_map *map, size_t index);
+
+    
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/drafter/ext/snowcrash/ext/markdown-parser/ext/sundown/src/stack.c

@@ -0,0 +1,81 @@
+#include "stack.h"
+#include <string.h>
+
+int
+stack_grow(struct stack *st, size_t new_size)
+{
+	void **new_st;
+
+	if (st->asize >= new_size)
+		return 0;
+
+	new_st = realloc(st->item, new_size * sizeof(void *));
+	if (new_st == NULL)
+		return -1;
+
+	memset(new_st + st->asize, 0x0,
+		(new_size - st->asize) * sizeof(void *));
+
+	st->item = new_st;
+	st->asize = new_size;
+
+	if (st->size > new_size)
+		st->size = new_size;
+
+	return 0;
+}
+
+void
+stack_free(struct stack *st)
+{
+	if (!st)
+		return;
+
+	free(st->item);
+
+	st->item = NULL;
+	st->size = 0;
+	st->asize = 0;
+}
+
+int
+stack_init(struct stack *st, size_t initial_size)
+{
+	st->item = NULL;
+	st->size = 0;
+	st->asize = 0;
+
+	if (!initial_size)
+		initial_size = 8;
+
+	return stack_grow(st, initial_size);
+}
+
+void *
+stack_pop(struct stack *st)
+{
+	if (!st->size)
+		return NULL;
+
+	return st->item[--st->size];
+}
+
+int
+stack_push(struct stack *st, void *item)
+{
+	if (stack_grow(st, st->size * 2) < 0)
+		return -1;
+
+	st->item[st->size++] = item;
+	return 0;
+}
+
+void *
+stack_top(struct stack *st)
+{
+	if (!st->size)
+		return NULL;
+
+	return st->item[st->size - 1];
+}
+

data/ext/drafter/ext/snowcrash/ext/markdown-parser/ext/sundown/src/stack.h

@@ -0,0 +1,29 @@
+#ifndef STACK_H__
+#define STACK_H__
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct stack {
+	void **item;
+	size_t size;
+	size_t asize;
+};
+
+void stack_free(struct stack *);
+int stack_grow(struct stack *, size_t);
+int stack_init(struct stack *, size_t);
+
+int stack_push(struct stack *, void *);
+
+void *stack_pop(struct stack *);
+void *stack_top(struct stack *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/drafter/ext/snowcrash/ext/markdown-parser/ext/sundown/sundown.def

@@ -0,0 +1,20 @@
+LIBRARY SUNDOWN
+EXPORTS
+	sdhtml_renderer
+	sdhtml_toc_renderer
+	sdhtml_smartypants
+	bufgrow
+	bufnew
+	bufcstr
+	bufprefix
+	bufput 
+	bufputs
+	bufputc
+	bufrelease
+	bufreset
+	bufslurp
+	bufprintf
+	sd_markdown_new
+	sd_markdown_render
+	sd_markdown_free
+	sd_version