rinku 1.0.0

data/ext/rinku/buffer.c

@@ -0,0 +1,323 @@
+/* buffer.c - automatic buffer structure */
+
+/*
+ * Copyright (c) 2008, 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.
+ */
+
+/*
+ * COMPILE TIME OPTIONS
+ *
+ * BUFFER_STATS • if defined, stats are kept about memory usage
+ */
+
+#define BUFFER_STDARG
+#define BUFFER_MAX_ALLOC_SIZE (1024 * 1024 * 16) //16mb
+
+#include "buffer.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/********************
+ * GLOBAL VARIABLES *
+ ********************/
+
+#ifdef BUFFER_STATS
+long buffer_stat_nb = 0;
+size_t buffer_stat_alloc_bytes = 0;
+#endif
+
+
+/***************************
+ * STATIC HELPER FUNCTIONS *
+ ***************************/
+
+/* lower • retruns the lower-case variant of the input char */
+static char
+lower(char c) {
+	return (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c; }
+
+
+
+/********************
+ * BUFFER FUNCTIONS *
+ ********************/
+
+/* bufcasecmp • case-insensitive buffer comparison */
+int
+bufcasecmp(const struct buf *a, const struct buf *b) {
+	size_t i = 0;
+	size_t cmplen;
+	if (a == b) return 0;
+	if (!a) return -1; else if (!b) return 1;
+	cmplen = (a->size < b->size) ? a->size : b->size;
+	while (i < cmplen && lower(a->data[i]) == lower(b->data[i])) ++i;
+	if (i < a->size) {
+		if (i < b->size)  return lower(a->data[i]) - lower(b->data[i]);
+		else		  return 1; }
+	else {	if (i < b->size)  return -1;
+		else		  return 0; } }
+
+
+/* bufcmp • case-sensitive buffer comparison */
+int
+bufcmp(const struct buf *a, const struct buf *b) {
+	size_t i = 0;
+	size_t cmplen;
+	if (a == b) return 0;
+	if (!a) return -1; else if (!b) return 1;
+	cmplen = (a->size < b->size) ? a->size : b->size;
+	while (i < cmplen && a->data[i] == b->data[i]) ++i;
+	if (i < a->size) {
+		if (i < b->size)	return a->data[i] - b->data[i];
+		else			return 1; }
+	else {	if (i < b->size)	return -1;
+		else			return 0; } }
+
+
+/* bufcmps • case-sensitive comparison of a string to a buffer */
+int
+bufcmps(const struct buf *a, const char *b) {
+	const size_t len = strlen(b);
+	size_t cmplen = len;
+	int r;
+	if (!a || !a->size) return b ? 0 : -1;
+	if (len < a->size) cmplen = a->size;
+	r = strncmp(a->data, b, cmplen);
+	if (r) return r;
+	else if (a->size == len) return 0;
+	else if (a->size < len) return -1;
+	else return 1; }
+
+int
+bufprefix(const struct buf *buf, const char *prefix)
+{
+	size_t i;
+
+	for (i = 0; i < buf->size; ++i) {
+		if (prefix[i] == 0)
+			return 0;
+
+		if (buf->data[i] != prefix[i])
+			return buf->data[i] - prefix[i];
+	}
+
+	return 0;
+}
+
+
+/* bufdup • buffer duplication */
+struct buf *
+bufdup(const struct buf *src, size_t dupunit) {
+	size_t blocks;
+	struct buf *ret;
+	if (src == 0) return 0;
+	ret = malloc(sizeof (struct buf));
+	if (ret == 0) return 0;
+	ret->unit = dupunit;
+	ret->size = src->size;
+	ret->ref = 1;
+	if (!src->size) {
+		ret->asize = 0;
+		ret->data = 0;
+		return ret; }
+	blocks = (src->size + dupunit - 1) / dupunit;
+	ret->asize = blocks * dupunit;
+	ret->data = malloc(ret->asize);
+	if (ret->data == 0) {
+		free(ret);
+		return 0; }
+	memcpy(ret->data, src->data, src->size);
+#ifdef BUFFER_STATS
+	buffer_stat_nb += 1;
+	buffer_stat_alloc_bytes += ret->asize;
+#endif
+	return ret; }
+
+/* bufgrow • increasing the allocated size to the given value */
+int
+bufgrow(struct buf *buf, size_t neosz) {
+	size_t neoasz;
+	void *neodata;
+	if (!buf || !buf->unit || neosz > BUFFER_MAX_ALLOC_SIZE) return 0;
+	if (buf->asize >= neosz) return 1;
+	neoasz = buf->asize + buf->unit;
+	while (neoasz < neosz) neoasz += buf->unit;
+	neodata = realloc(buf->data, neoasz);
+	if (!neodata) return 0;
+#ifdef BUFFER_STATS
+	buffer_stat_alloc_bytes += (neoasz - buf->asize);
+#endif
+	buf->data = neodata;
+	buf->asize = neoasz;
+	return 1; }
+
+
+/* bufnew • allocation of a new buffer */
+struct buf *
+bufnew(size_t unit) {
+	struct buf *ret;
+	ret = malloc(sizeof (struct buf));
+	if (ret) {
+#ifdef BUFFER_STATS
+		buffer_stat_nb += 1;
+#endif
+		ret->data = 0;
+		ret->size = ret->asize = 0;
+		ret->ref = 1;
+		ret->unit = unit; }
+	return ret; }
+
+
+/* bufnullterm • NUL-termination of the string array (making a C-string) */
+void
+bufnullterm(struct buf *buf) {
+	if (!buf || !buf->unit) return;
+	if (buf->size < buf->asize && buf->data[buf->size] == 0) return;
+	if (buf->size + 1 <= buf->asize || bufgrow(buf, buf->size + 1))
+		buf->data[buf->size] = 0; }
+
+
+/* bufprintf • formatted printing to a buffer */
+void
+bufprintf(struct buf *buf, const char *fmt, ...) {
+	va_list ap;
+	if (!buf || !buf->unit) return;
+	va_start(ap, fmt);
+	vbufprintf(buf, fmt, ap);
+	va_end(ap); }
+
+
+/* bufput • appends raw data to a buffer */
+void
+bufput(struct buf *buf, const void *data, size_t len) {
+	if (!buf) return;
+	if (buf->size + len > buf->asize && !bufgrow(buf, buf->size + len))
+		return;
+	memcpy(buf->data + buf->size, data, len);
+	buf->size += len; }
+
+
+/* bufputs • appends a NUL-terminated string to a buffer */
+void
+bufputs(struct buf *buf, const char *str) {
+	bufput(buf, str, strlen (str)); }
+
+
+/* bufputc • appends a single char to a buffer */
+void
+bufputc(struct buf *buf, char c) {
+	if (!buf) return;
+	if (buf->size + 1 > buf->asize && !bufgrow(buf, buf->size + 1))
+		return;
+	buf->data[buf->size] = c;
+	buf->size += 1; }
+
+
+/* bufrelease • decrease the reference count and free the buffer if needed */
+void
+bufrelease(struct buf *buf) {
+	if (!buf) return;
+	buf->ref -= 1;
+	if (buf->ref == 0) {
+#ifdef BUFFER_STATS
+		buffer_stat_nb -= 1;
+		buffer_stat_alloc_bytes -= buf->asize;
+#endif
+		free(buf->data);
+		free(buf); } }
+
+
+/* bufreset • frees internal data of the buffer */
+void
+bufreset(struct buf *buf) {
+	if (!buf) return;
+#ifdef BUFFER_STATS
+	buffer_stat_alloc_bytes -= buf->asize;
+#endif
+	free(buf->data);
+	buf->data = 0;
+	buf->size = buf->asize = 0; }
+
+
+/* bufset • safely assigns a buffer to another */
+void
+bufset(struct buf **dest, struct buf *src) {
+	if (src) {
+		if (!src->asize) src = bufdup(src, 1);
+		else src->ref += 1; }
+	bufrelease(*dest);
+	*dest = src; }
+
+
+/* bufslurp • removes a given number of bytes from the head of the array */
+void
+bufslurp(struct buf *buf, size_t len) {
+	if (!buf || !buf->unit || len <= 0) return;
+	if (len >= buf->size) {
+		buf->size = 0;
+		return; }
+	buf->size -= len;
+	memmove(buf->data, buf->data + len, buf->size); }
+
+
+/* buftoi • converts the numbers at the beginning of the buf into an int */
+int
+buftoi(struct buf *buf, size_t offset_i, size_t *offset_o) {
+	int r = 0, neg = 0;
+	size_t i = offset_i;
+	if (!buf || !buf->size) return 0;
+	if (buf->data[i] == '+') i += 1;
+	else if (buf->data[i] == '-') {
+		neg = 1;
+		i += 1; }
+	while (i < buf->size && buf->data[i] >= '0' && buf->data[i] <= '9') {
+		r = (r * 10) + buf->data[i] - '0';
+		i += 1; }
+	if (offset_o) *offset_o = i;
+	return neg ? -r : r; }
+
+
+
+/* vbufprintf • stdarg variant of formatted printing into a buffer */
+void
+vbufprintf(struct buf *buf, const char *fmt, va_list ap) {
+	int n;
+	va_list ap_save;
+	if (buf == 0
+	|| (buf->size >= buf->asize && !bufgrow (buf, buf->size + 1)))
+		return;
+
+	va_copy(ap_save, ap);
+	n = vsnprintf(buf->data + buf->size, buf->asize - buf->size, fmt, ap);
+
+	if (n < 0 || (size_t)n >= buf->asize - buf->size) {
+		size_t new_size = (n > 0) ? n : buf->size;
+		if (!bufgrow (buf, buf->size + new_size + 1))
+			return;
+
+		n = vsnprintf(buf->data + buf->size, buf->asize - buf->size, fmt, ap_save);
+	}
+	va_end(ap_save);
+
+	if (n < 0)
+		return;
+
+	buf->size += n;
+}
+
+/* vim: set filetype=c: */

data/ext/rinku/buffer.h

@@ -0,0 +1,154 @@
+/* buffer.h - automatic buffer structure */
+
+/*
+ * Copyright (c) 2008, 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 LITHIUM_BUFFER_H
+#define LITHIUM_BUFFER_H
+
+#include <stddef.h>
+
+#if defined(_MSC_VER)
+#define __attribute__(x)
+#define inline
+#define strncasecmp _strnicmp
+#define snprintf _snprintf
+#define va_copy(d,s) ((d) = (s))
+#endif
+
+/********************
+ * TYPE DEFINITIONS *
+ ********************/
+
+/* struct buf • character array buffer */
+struct buf {
+	char *	data;	/* actual character data */
+	size_t	size;	/* size of the string */
+	size_t	asize;	/* allocated size (0 = volatile buffer) */
+	size_t	unit;	/* reallocation unit size (0 = read-only buffer) */
+	int	ref; };	/* reference count */
+
+/**********
+ * MACROS *
+ **********/
+
+#define STRLEN(x) (sizeof(x) - 1)
+
+/* CONST_BUF • global buffer from a string litteral */
+#define CONST_BUF(name, string) \
+	static struct buf name = { string, sizeof string -1, sizeof string }
+
+
+/* VOLATILE_BUF • macro for creating a volatile buffer on the stack */
+#define VOLATILE_BUF(name, strname) \
+	struct buf name = { strname, strlen(strname) }
+
+
+/* BUFPUTSL • optimized bufputs of a string litteral */
+#define BUFPUTSL(output, litteral) \
+	bufput(output, litteral, sizeof litteral - 1)
+
+
+
+/********************
+ * BUFFER FUNCTIONS *
+ ********************/
+
+/* bufcasecmp • case-insensitive buffer comparison */
+int
+bufcasecmp(const struct buf *, const struct buf *);
+
+/* bufcmp • case-sensitive buffer comparison */
+int
+bufcmp(const struct buf *, const struct buf *);
+
+/* bufcmps • case-sensitive comparison of a string to a buffer */
+int
+bufcmps(const struct buf *, const char *);
+
+/* bufprefix * compare the beginning of a buffer with a string */
+int
+bufprefix(const struct buf *buf, const char *prefix);
+
+/* bufdup • buffer duplication */
+struct buf *
+bufdup(const struct buf *, size_t)
+	__attribute__ ((malloc));
+
+/* bufgrow • increasing the allocated size to the given value */
+int
+bufgrow(struct buf *, size_t);
+
+/* bufnew • allocation of a new buffer */
+struct buf *
+bufnew(size_t)
+	__attribute__ ((malloc));
+
+/* bufnullterm • NUL-termination of the string array (making a C-string) */
+void
+bufnullterm(struct buf *);
+
+/* bufprintf • formatted printing to a buffer */
+void
+bufprintf(struct buf *, const char *, ...)
+	__attribute__ ((format (printf, 2, 3)));
+
+/* bufput • appends raw data to a buffer */
+void
+bufput(struct buf *, const void*, size_t);
+
+/* bufputs • appends a NUL-terminated string to a buffer */
+void
+bufputs(struct buf *, const char*);
+
+/* bufputc • appends a single char to a buffer */
+void
+bufputc(struct buf *, char);
+
+/* bufrelease • decrease the reference count and free the buffer if needed */
+void
+bufrelease(struct buf *);
+
+/* bufreset • frees internal data of the buffer */
+void
+bufreset(struct buf *);
+
+/* bufset • safely assigns a buffer to another */
+void
+bufset(struct buf **, struct buf *);
+
+/* bufslurp • removes a given number of bytes from the head of the array */
+void
+bufslurp(struct buf *, size_t);
+
+/* buftoi • converts the numbers at the beginning of the buf into an int */
+int
+buftoi(struct buf *, size_t, size_t *);
+
+
+
+#ifdef BUFFER_STDARG
+#include <stdarg.h>
+
+/* vbufprintf • stdarg variant of formatted printing into a buffer */
+void
+vbufprintf(struct buf *, const char*, va_list);
+
+#endif /* def BUFFER_STDARG */
+
+#endif /* ndef LITHIUM_BUFFER_H */
+
+/* vim: set filetype=c: */

data/ext/rinku/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+dir_config('rinku')
+create_makefile('rinku')

data/ext/rinku/html_autolink.c

@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2011, Vicent Marti
+ *
+ * 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.
+ */
+
+#include "autolink.h"
+#include "buffer.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+
+static void
+autolink_escape_cb(struct buf *ob, const struct buf *text, void *unused)
+{
+	size_t  i = 0, org;
+
+	while (i < text->size) {
+		org = i;
+
+		while (i < text->size &&
+			text->data[i] != '<' &&
+			text->data[i] != '>' &&
+			text->data[i] != '&' &&
+			text->data[i] != '"')
+			i++;
+
+		if (i > org)
+			bufput(ob, text->data + org, i - org);
+
+		if (i >= text->size)
+			break;
+
+		switch (text->data[i]) {
+			case '<': BUFPUTSL(ob, "&lt;"); break;
+			case '>': BUFPUTSL(ob, "&gt;"); break;
+			case '&': BUFPUTSL(ob, "&amp;"); break;
+			case '"': BUFPUTSL(ob, "&quot;"); break;
+			default: bufputc(ob, text->data[i]); break;
+		}
+
+		i++;
+	}
+}
+
+static inline int
+is_closing_a(const char *tag, size_t size)
+{
+	size_t i;
+
+	if (tag[0] != '<' || size < STRLEN("</a>") || tag[1] != '/')
+		return 0;
+
+	i = 2;
+
+	while (i < size && isspace(tag[i]))
+		i++;
+
+	if (i == size || tag[i] != 'a')
+		return 0;
+
+	i++;
+
+	while (i < size && isspace(tag[i]))
+		i++;
+
+	if (i == size || tag[i] != '>')
+		return 0;
+
+	return i;
+}
+
+static size_t
+skip_tags(struct buf *ob, const char *text, size_t size)
+{
+	size_t i = 0;
+
+	while (i < size && text[i] != '>')
+		i++;
+
+	if (size > 3 && text[1] == 'a' && isspace(text[2])) {
+		while (i < size) {
+			size_t tag_len = is_closing_a(text + i, size - i);
+			if (tag_len) {
+				i += tag_len;
+				break;
+			}
+			i++;
+		}
+	}
+
+	bufput(ob, text, i + 1);
+	return i + 1;
+}
+
+void
+upshtml_autolink(
+	struct buf *ob,
+	struct buf *text,
+	unsigned int flags,
+	const char *link_attr,
+	void (*link_text_cb)(struct buf *ob, const struct buf *link, void *payload),
+	void *payload)
+{
+	size_t i, end;
+	struct buf *link = bufnew(16);
+	const char *active_chars;
+
+	if (!text || text->size == 0)
+		return;
+
+	switch (flags) {
+		case AUTOLINK_EMAILS:
+			active_chars = "<@";
+			break;
+
+		case AUTOLINK_URLS:
+			active_chars = "<w:";
+
+		case AUTOLINK_ALL:
+			active_chars = "<@w:";
+			break;
+
+		default:
+			return;
+	}
+
+	if (link_text_cb == NULL)
+		link_text_cb = &autolink_escape_cb;
+
+	bufgrow(ob, text->size);
+
+	i = end = 0;
+
+	while (i < text->size) {
+		size_t rewind;
+
+		while (end < text->size && strchr(active_chars, text->data[end]) == NULL)
+			end++;
+
+		bufput(ob, text->data + i, end - i);
+
+		if (end >= text->size)
+			break;
+
+		i = end;
+		link->size = 0;
+
+		switch (text->data[i]) {
+		case '@':
+			end = ups_autolink__email(&rewind, link, text->data + i, i, text->size - i);
+			if (end > 0) {
+				ob->size -= rewind;
+				BUFPUTSL(ob, "<a");
+				if (link_attr) bufputs(ob, link_attr);
+				BUFPUTSL(ob, " href=\"mailto:");
+				bufput(ob, link->data, link->size);
+				BUFPUTSL(ob, "\">");
+				link_text_cb(ob, link, payload);
+				BUFPUTSL(ob, "</a>");
+			}
+			break;
+
+		case 'w':
+			end = ups_autolink__www(&rewind, link, text->data + i, i, text->size - i);
+			if (end > 0) {
+				BUFPUTSL(ob, "<a");
+				if (link_attr) bufputs(ob, link_attr);
+				BUFPUTSL(ob, " href=\"http://");
+				bufput(ob, link->data, link->size);
+				BUFPUTSL(ob, "\">");
+				link_text_cb(ob, link, payload);
+				BUFPUTSL(ob, "</a>");
+			}
+			break;
+
+		case ':':
+			end = ups_autolink__url(&rewind, link, text->data + i, i, text->size - i);
+			if (end > 0) {
+				ob->size -= rewind;
+				BUFPUTSL(ob, "<a");
+				if (link_attr) bufputs(ob, link_attr);
+				BUFPUTSL(ob, " href=\"");
+				bufput(ob, link->data, link->size);
+				BUFPUTSL(ob, "\">");
+				link_text_cb(ob, link, payload);
+				BUFPUTSL(ob, "</a>");
+			}
+			break;
+
+		case '<':
+			end = skip_tags(ob, text->data + i, text->size - i);
+			break;
+
+		default:
+			end = 0;
+			break;
+		}
+
+		if (!end)
+			end = i + 1;
+		else { 
+			i += end;
+			end = i;
+		} 
+	}
+}
+
+