added "namespace" (prefix) sd_ for all the markdown library

17 files changed, 541 insertions, 534 deletions

diff --git a/ascii.lua b/ascii.lua
index fa68b22..de72f41 100644
--- a/ascii.lua
+++ b/ascii.lua
@@ -88,12 +88,6 @@ local bw_style = {
 
 local default_style = color_style
 
-ffi.cdef[[
-struct sd_buf *bufnew(size_t) __attribute__ ((malloc));
-void bufputs(struct sd_buf *, const char *);
-void bufrelease(struct sd_buf *);
-]]
-
 local function textsize(text)
    local szt = 0
    local nw = 0
@@ -124,7 +118,7 @@ local function createcallbacks(style)
                text = style.code .. text .. style.none
                n = n+1
                tree[n] = {tag='blockcode', text=text}
-               C.bufputs(ob, '\030' .. n .. '\031')
+               C.sd_bufputs(ob, '\030' .. n .. '\031')
             end
          end,
 
@@ -136,7 +130,7 @@ local function createcallbacks(style)
                text = style['h' .. level] .. text .. style.none
                n = n+1
                tree[n] = {tag='header', text=text, level=level}
-               C.bufputs(ob, '\030' .. n .. '\031')
+               C.sd_bufputs(ob, '\030' .. n .. '\031')
             end
          end,
 
@@ -147,7 +141,7 @@ local function createcallbacks(style)
                text = style.blockquote .. text .. style.none
                n = n+1
                tree[n] = {tag='blockquote', text=text}
-               C.bufputs(ob, '\030' .. n .. '\031')
+               C.sd_bufputs(ob, '\030' .. n .. '\031')
             end
          end,
 
@@ -160,7 +154,7 @@ local function createcallbacks(style)
          function(ob, opaque)
             n = n+1
             tree[n] = {tag='hrule'}
-            C.bufputs(ob, '\030' .. n .. '\031')
+            C.sd_bufputs(ob, '\030' .. n .. '\031')
          end,
       
       paragraph =
@@ -169,7 +163,7 @@ local function createcallbacks(style)
                text = ffi.string(text.data, text.size)
                n = n+1
                tree[n] = {tag='paragraph', text=text}
-               C.bufputs(ob, '\030' .. n .. '\031')
+               C.sd_bufputs(ob, '\030' .. n .. '\031')
             end
          end,
 
@@ -190,7 +184,7 @@ local function createcallbacks(style)
             if text or header then
                n = n+1
                tree[n] = {tag='tbl', text=text, header=header}
-               C.bufputs(ob, '\030' .. n .. '\031')
+               C.sd_bufputs(ob, '\030' .. n .. '\031')
             end
          end,
 
@@ -200,7 +194,7 @@ local function createcallbacks(style)
                text = ffi.string(text.data, text.size)
                n = n+1
                tree[n] = {tag='tblrow', text=text}
-               C.bufputs(ob, '\030' .. n .. '\031')
+               C.sd_bufputs(ob, '\030' .. n .. '\031')
             end
          end,
 
@@ -221,7 +215,7 @@ local function createcallbacks(style)
                   right=(flags==2),
                   center=(flags==3)
                }            
-               C.bufputs(ob, '\030' .. n .. '\031')
+               C.sd_bufputs(ob, '\030' .. n .. '\031')
             end
          end,
 
@@ -231,7 +225,7 @@ local function createcallbacks(style)
                text = ffi.string(text.data, text.size)
                n = n+1
                tree[n] = {tag='list', text=text, type=bit.band(flags, 1)}
-               C.bufputs(ob, '\030' .. n .. '\031')
+               C.sd_bufputs(ob, '\030' .. n .. '\031')
             end 
          end,
 
@@ -241,7 +235,7 @@ local function createcallbacks(style)
                text = ffi.string(text.data, text.size)
                n = n+1
                tree[n] = {tag='listitem', text=text}
-               C.bufputs(ob, '\030' .. n .. '\031')
+               C.sd_bufputs(ob, '\030' .. n .. '\031')
             end
          end,
 
@@ -250,7 +244,7 @@ local function createcallbacks(style)
             if text ~= nil and text.data ~= nil then
                text = ffi.string(text.data, text.size)
                text = text:gsub('[\029\030\031]', '')
-               C.bufputs(ob, text)
+               C.sd_bufputs(ob, text)
             end
          end,
 
@@ -259,7 +253,7 @@ local function createcallbacks(style)
             if text ~= nil and text.data ~= nil then
                text = ffi.string(text.data, text.size)
                text = text:gsub('[\029\030\031]', '')
-               C.bufputs(ob, text)
+               C.sd_bufputs(ob, text)
             end
          end,
 
@@ -268,7 +262,7 @@ local function createcallbacks(style)
             if link ~= nil and link.data ~= nil then
                link = ffi.string(link.data, link.size)
                link = style.link .. link .. style.none
-               C.bufputs(ob, link)
+               C.sd_bufputs(ob, link)
             end
             return 1
          end,
@@ -278,7 +272,7 @@ local function createcallbacks(style)
             if text ~= nil and text.data ~= nil then
                text = ffi.string(text.data, text.size)
                text = style.code .. text .. style.none
-               C.bufputs(ob, text)
+               C.sd_bufputs(ob, text)
             end
             return 1
          end,
@@ -287,7 +281,7 @@ local function createcallbacks(style)
          function(ob, text, opaque)
             if text ~= nil and text.data ~= nil then
                text = style.doubleemph .. ffi.string(text.data, text.size) .. style.none
-               C.bufputs(ob, text)
+               C.sd_bufputs(ob, text)
             end
             return 1
          end,
@@ -296,7 +290,7 @@ local function createcallbacks(style)
          function(ob, text, opaque)
             if text ~= nil and text.data ~= nil then
                text = style.emph .. ffi.string(text.data, text.size) .. style.none
-               C.bufputs(ob, text)
+               C.sd_bufputs(ob, text)
             end
             return 1
          end,
@@ -312,14 +306,14 @@ local function createcallbacks(style)
                text = text .. ffi.string(link.data, link.size)
             end
             text = text .. ']' .. style.none
-            C.bufputs(ob, text)
+            C.sd_bufputs(ob, text)
             return 1
          end,
 
       linebreak =
          function(ob, opaque)
             local text = '\029'
-            C.bufputs(ob, text)   
+            C.sd_bufputs(ob, text)
          end,
       
       link =
@@ -335,7 +329,7 @@ local function createcallbacks(style)
                end
             end
             if #text > 0 then
-               C.bufputs(ob, text)
+               C.sd_bufputs(ob, text)
             end
             return 1
          end,
@@ -350,7 +344,7 @@ local function createcallbacks(style)
          function(ob, text, opaque)
             if text ~= nil and text.data ~= nil then
                text = style.tripleemph .. ffi.string(text.data, text.size) .. style.none
-               C.bufputs(ob, text)
+               C.sd_bufputs(ob, text)
             end
             return 1
          end,
@@ -359,7 +353,7 @@ local function createcallbacks(style)
          function(ob, text, opaque)
             if text ~= nil and text.data ~= nil then
                text = style.strikethrough .. ffi.string(text.data, text.size) .. style.none
-               C.bufputs(ob, text)
+               C.sd_bufputs(ob, text)
             end
             return 1
          end,
@@ -368,7 +362,7 @@ local function createcallbacks(style)
          function(ob, text, opaque)
             if text ~= nil and text.data ~= nil then
                text = style.superscript .. ffi.string(text.data, text.size) .. style.none
-               C.bufputs(ob, text)
+               C.sd_bufputs(ob, text)
             end
             return 1
          end,
@@ -391,7 +385,7 @@ local function preprocess(txt, style)
    local c_callbacks = ffi.new('struct sd_callbacks', callbacks)
    local markdown = C.sd_markdown_new(0xfff, 16, c_callbacks, options)
    
-   local outbuf = C.bufnew(64)
+   local outbuf = C.sd_bufnew(64)
    
    C.sd_markdown_render(outbuf, ffi.cast('const char*', txt), #txt, markdown)
    C.sd_markdown_free(markdown)
@@ -401,7 +395,7 @@ local function preprocess(txt, style)
    end
 
    txt = ffi.string(outbuf.data, outbuf.size)
-   C.bufrelease(outbuf)
+   C.sd_bufrelease(outbuf)
 
    return txt, tree
 end
diff --git a/html/houdini.h b/html/houdini.h
index b4954c0..6fbecc3 100644
--- a/html/houdini.h
+++ b/html/houdini.h
@@ -18,17 +18,17 @@ extern "C" {
 #	define _isdigit(c) ((c) >= '0' && (c) <= '9')
 #endif
 
-extern void houdini_escape_html(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_escape_html0(struct buf *ob, const uint8_t *src, size_t size, int secure);
-extern void houdini_unescape_html(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_escape_xml(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_escape_uri(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_escape_url(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_escape_href(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_unescape_uri(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_unescape_url(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_escape_js(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_unescape_js(struct buf *ob, const uint8_t *src, size_t size);
+extern void sd_houdini_escape_html(struct sd_buf *ob, const uint8_t *src, size_t size);
+extern void sd_houdini_escape_html0(struct sd_buf *ob, const uint8_t *src, size_t size, int secure);
+extern void sd_houdini_unescape_html(struct sd_buf *ob, const uint8_t *src, size_t size);
+extern void sd_houdini_escape_xml(struct sd_buf *ob, const uint8_t *src, size_t size);
+extern void sd_houdini_escape_uri(struct sd_buf *ob, const uint8_t *src, size_t size);
+extern void sd_houdini_escape_url(struct sd_buf *ob, const uint8_t *src, size_t size);
+extern void sd_houdini_escape_href(struct sd_buf *ob, const uint8_t *src, size_t size);
+extern void sd_houdini_unescape_uri(struct sd_buf *ob, const uint8_t *src, size_t size);
+extern void sd_houdini_unescape_url(struct sd_buf *ob, const uint8_t *src, size_t size);
+extern void sd_houdini_escape_js(struct sd_buf *ob, const uint8_t *src, size_t size);
+extern void sd_houdini_unescape_js(struct sd_buf *ob, const uint8_t *src, size_t size);
 
 #ifdef __cplusplus
 }
diff --git a/html/houdini_href_e.c b/html/houdini_href_e.c
index 981b3b1..539bbfe 100644
--- a/html/houdini_href_e.c
+++ b/html/houdini_href_e.c
@@ -51,13 +51,13 @@ static const char HREF_SAFE[] = {
 };
 
 void
-houdini_escape_href(struct buf *ob, const uint8_t *src, size_t size)
+sd_houdini_escape_href(struct sd_buf *ob, const uint8_t *src, size_t size)
 {
 	static const char hex_chars[] = "0123456789ABCDEF";
 	size_t  i = 0, org;
 	char hex_str[3];
 
-	bufgrow(ob, ESCAPE_GROW_FACTOR(size));
+	sd_bufgrow(ob, ESCAPE_GROW_FACTOR(size));
 	hex_str[0] = '%';
 
 	while (i < size) {
@@ -66,7 +66,7 @@ houdini_escape_href(struct buf *ob, const uint8_t *src, size_t size)
 			i++;
 
 		if (i > org)
-			bufput(ob, src + org, i - org);
+			sd_bufput(ob, src + org, i - org);
 
 		/* escaping */
 		if (i >= size)
@@ -92,7 +92,7 @@ houdini_escape_href(struct buf *ob, const uint8_t *src, size_t size)
 		 * when building GET strings */
 #if 0
 		case ' ':
-			bufputc(ob, '+');
+			sd_bufputc(ob, '+');
 			break;
 #endif
 
@@ -100,7 +100,7 @@ houdini_escape_href(struct buf *ob, const uint8_t *src, size_t size)
 		default:
 			hex_str[1] = hex_chars[(src[i] >> 4) & 0xF];
 			hex_str[2] = hex_chars[src[i] & 0xF];
-			bufput(ob, hex_str, 3);
+			sd_bufput(ob, hex_str, 3);
 		}
 
 		i++;
diff --git a/html/houdini_html_e.c b/html/houdini_html_e.c
index d9bbf18..52a1cd0 100644
--- a/html/houdini_html_e.c
+++ b/html/houdini_html_e.c
@@ -47,11 +47,11 @@ static const char *HTML_ESCAPES[] = {
 };
 
 void
-houdini_escape_html0(struct buf *ob, const uint8_t *src, size_t size, int secure)
+sd_houdini_escape_html0(struct sd_buf *ob, const uint8_t *src, size_t size, int secure)
 {
 	size_t i = 0, org, esc = 0;
 
-	bufgrow(ob, ESCAPE_GROW_FACTOR(size));
+	sd_bufgrow(ob, ESCAPE_GROW_FACTOR(size));
 
 	while (i < size) {
 		org = i;
@@ -59,7 +59,7 @@ houdini_escape_html0(struct buf *ob, const uint8_t *src, size_t size, int secure
 			i++;
 
 		if (i > org)
-			bufput(ob, src + org, i - org);
+			sd_bufput(ob, src + org, i - org);
 
 		/* escaping */
 		if (i >= size)
@@ -67,9 +67,9 @@ houdini_escape_html0(struct buf *ob, const uint8_t *src, size_t size, int secure
 
 		/* The forward slash is only escaped in secure mode */
 		if (src[i] == '/' && !secure) {
-			bufputc(ob, '/');
+			sd_bufputc(ob, '/');
 		} else {
-			bufputs(ob, HTML_ESCAPES[esc]);
+			sd_bufputs(ob, HTML_ESCAPES[esc]);
 		}
 
 		i++;
@@ -77,8 +77,8 @@ houdini_escape_html0(struct buf *ob, const uint8_t *src, size_t size, int secure
 }
 
 void
-houdini_escape_html(struct buf *ob, const uint8_t *src, size_t size)
+sd_houdini_escape_html(struct sd_buf *ob, const uint8_t *src, size_t size)
 {
-	houdini_escape_html0(ob, src, size, 1);
+	sd_houdini_escape_html0(ob, src, size, 1);
 }
 
diff --git a/html/html.c b/html/html.c
index 7f08ee8..a9c6660 100644
--- a/html/html.c
+++ b/html/html.c
@@ -28,7 +28,7 @@
 #define USE_XHTML(opt) (opt->flags & HTML_USE_XHTML)
 
 int
-sdhtml_is_tag(const uint8_t *tag_data, size_t tag_size, const char *tagname)
+sd_html_is_tag(const uint8_t *tag_data, size_t tag_size, const char *tagname)
 {
 	size_t i;
 	int closed = 0;
@@ -60,23 +60,23 @@ sdhtml_is_tag(const uint8_t *tag_data, size_t tag_size, const char *tagname)
 	return HTML_TAG_NONE;
 }
 
-static inline void escape_html(struct buf *ob, const uint8_t *source, size_t length)
+static inline void escape_html(struct sd_buf *ob, const uint8_t *source, size_t length)
 {
-	houdini_escape_html0(ob, source, length, 0);
+	sd_houdini_escape_html0(ob, source, length, 0);
 }
 
-static inline void escape_href(struct buf *ob, const uint8_t *source, size_t length)
+static inline void escape_href(struct sd_buf *ob, const uint8_t *source, size_t length)
 {
-	houdini_escape_href(ob, source, length);
+	sd_houdini_escape_href(ob, source, length);
 }
 
 /********************
  * GENERIC RENDERER *
  ********************/
 static int
-rndr_autolink(struct buf *ob, const struct buf *link, enum mkd_autolink type, void *opaque)
+rndr_autolink(struct sd_buf *ob, const struct sd_buf *link, enum sd_mkd_autolink type, void *opaque)
 {
-	struct html_renderopt *options = opaque;
+	struct sd_html_renderopt *options = opaque;
 
 	if (!link || !link->size)
 		return 0;
@@ -92,9 +92,9 @@ rndr_autolink(struct buf *ob, const struct buf *link, enum mkd_autolink type, vo
 	escape_href(ob, link->data, link->size);
 
 	if (options->link_attributes) {
-		bufputc(ob, '\"');
+		sd_bufputc(ob, '\"');
 		options->link_attributes(ob, link, opaque);
-		bufputc(ob, '>');
+		sd_bufputc(ob, '>');
 	} else {
 		BUFPUTSL(ob, "\">");
 	}
@@ -104,7 +104,7 @@ rndr_autolink(struct buf *ob, const struct buf *link, enum mkd_autolink type, vo
 	 * an actual URI, e.g. `mailto:foo@bar.com`, we don't
 	 * want to print the `mailto:` prefix
 	 */
-	if (bufprefix(link, "mailto:") == 0) {
+	if (sd_bufprefix(link, "mailto:") == 0) {
 		escape_html(ob, link->data + 7, link->size - 7);
 	} else {
 		escape_html(ob, link->data, link->size);
@@ -116,9 +116,9 @@ rndr_autolink(struct buf *ob, const struct buf *link, enum mkd_autolink type, vo
 }
 
 static void
-rndr_blockcode(struct buf *ob, const struct buf *text, const struct buf *lang, void *opaque)
+rndr_blockcode(struct sd_buf *ob, const struct sd_buf *text, const struct sd_buf *lang, void *opaque)
 {
-	if (ob->size) bufputc(ob, '\n');
+	if (ob->size) sd_bufputc(ob, '\n');
 
 	if (lang && lang->size) {
 		size_t i, cls;
@@ -136,7 +136,7 @@ rndr_blockcode(struct buf *ob, const struct buf *text, const struct buf *lang, v
 				if (lang->data[org] == '.')
 					org++;
 
-				if (cls) bufputc(ob, ' ');
+				if (cls) sd_bufputc(ob, ' ');
 				escape_html(ob, lang->data + org, i - org);
 			}
 		}
@@ -152,16 +152,16 @@ rndr_blockcode(struct buf *ob, const struct buf *text, const struct buf *lang, v
 }
 
 static void
-rndr_blockquote(struct buf *ob, const struct buf *text, void *opaque)
+rndr_blockquote(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
-	if (ob->size) bufputc(ob, '\n');
+	if (ob->size) sd_bufputc(ob, '\n');
 	BUFPUTSL(ob, "<blockquote>\n");
-	if (text) bufput(ob, text->data, text->size);
+	if (text) sd_bufput(ob, text->data, text->size);
 	BUFPUTSL(ob, "</blockquote>\n");
 }
 
 static int
-rndr_codespan(struct buf *ob, const struct buf *text, void *opaque)
+rndr_codespan(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
 	BUFPUTSL(ob, "<code>");
 	if (text) escape_html(ob, text->data, text->size);
@@ -170,69 +170,69 @@ rndr_codespan(struct buf *ob, const struct buf *text, void *opaque)
 }
 
 static int
-rndr_strikethrough(struct buf *ob, const struct buf *text, void *opaque)
+rndr_strikethrough(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
 	if (!text || !text->size)
 		return 0;
 
 	BUFPUTSL(ob, "<del>");
-	bufput(ob, text->data, text->size);
+	sd_bufput(ob, text->data, text->size);
 	BUFPUTSL(ob, "</del>");
 	return 1;
 }
 
 static int
-rndr_double_emphasis(struct buf *ob, const struct buf *text, void *opaque)
+rndr_double_emphasis(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
 	if (!text || !text->size)
 		return 0;
 
 	BUFPUTSL(ob, "<strong>");
-	bufput(ob, text->data, text->size);
+	sd_bufput(ob, text->data, text->size);
 	BUFPUTSL(ob, "</strong>");
 
 	return 1;
 }
 
 static int
-rndr_emphasis(struct buf *ob, const struct buf *text, void *opaque)
+rndr_emphasis(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
 	if (!text || !text->size) return 0;
 	BUFPUTSL(ob, "<em>");
-	if (text) bufput(ob, text->data, text->size);
+	if (text) sd_bufput(ob, text->data, text->size);
 	BUFPUTSL(ob, "</em>");
 	return 1;
 }
 
 static int
-rndr_linebreak(struct buf *ob, void *opaque)
+rndr_linebreak(struct sd_buf *ob, void *opaque)
 {
-	struct html_renderopt *options = opaque;
-	bufputs(ob, USE_XHTML(options) ? "<br/>\n" : "<br>\n");
+	struct sd_html_renderopt *options = opaque;
+	sd_bufputs(ob, USE_XHTML(options) ? "<br/>\n" : "<br>\n");
 	return 1;
 }
 
 static void
-rndr_header(struct buf *ob, const struct buf *text, int level, void *opaque)
+rndr_header(struct sd_buf *ob, const struct sd_buf *text, int level, void *opaque)
 {
-	struct html_renderopt *options = opaque;
+	struct sd_html_renderopt *options = opaque;
 
 	if (ob->size)
-		bufputc(ob, '\n');
+		sd_bufputc(ob, '\n');
 
 	if (options->flags & HTML_TOC)
-		bufprintf(ob, "<h%d id=\"toc_%d\">", level, options->toc_data.header_count++);
+		sd_bufprintf(ob, "<h%d id=\"toc_%d\">", level, options->toc_data.header_count++);
 	else
-		bufprintf(ob, "<h%d>", level);
+		sd_bufprintf(ob, "<h%d>", level);
 
-	if (text) bufput(ob, text->data, text->size);
-	bufprintf(ob, "</h%d>\n", level);
+	if (text) sd_bufput(ob, text->data, text->size);
+	sd_bufprintf(ob, "</h%d>\n", level);
 }
 
 static int
-rndr_link(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque)
+rndr_link(struct sd_buf *ob, const struct sd_buf *link, const struct sd_buf *title, const struct sd_buf *content, void *opaque)
 {
-	struct html_renderopt *options = opaque;
+	struct sd_html_renderopt *options = opaque;
 
 	if (link != NULL && (options->flags & HTML_SAFELINK) != 0 && !sd_autolink_issafe(link->data, link->size))
 		return 0;
@@ -248,29 +248,29 @@ rndr_link(struct buf *ob, const struct buf *link, const struct buf *title, const
 	}
 
 	if (options->link_attributes) {
-		bufputc(ob, '\"');
+		sd_bufputc(ob, '\"');
 		options->link_attributes(ob, link, opaque);
-		bufputc(ob, '>');
+		sd_bufputc(ob, '>');
 	} else {
 		BUFPUTSL(ob, "\">");
 	}
 
-	if (content && content->size) bufput(ob, content->data, content->size);
+	if (content && content->size) sd_bufput(ob, content->data, content->size);
 	BUFPUTSL(ob, "</a>");
 	return 1;
 }
 
 static void
-rndr_list(struct buf *ob, const struct buf *text, int flags, void *opaque)
+rndr_list(struct sd_buf *ob, const struct sd_buf *text, int flags, void *opaque)
 {
-	if (ob->size) bufputc(ob, '\n');
-	bufput(ob, flags & MKD_LIST_ORDERED ? "<ol>\n" : "<ul>\n", 5);
-	if (text) bufput(ob, text->data, text->size);
-	bufput(ob, flags & MKD_LIST_ORDERED ? "</ol>\n" : "</ul>\n", 6);
+	if (ob->size) sd_bufputc(ob, '\n');
+	sd_bufput(ob, flags & MKD_LIST_ORDERED ? "<ol>\n" : "<ul>\n", 5);
+	if (text) sd_bufput(ob, text->data, text->size);
+	sd_bufput(ob, flags & MKD_LIST_ORDERED ? "</ol>\n" : "</ul>\n", 6);
 }
 
 static void
-rndr_listitem(struct buf *ob, const struct buf *text, int flags, void *opaque)
+rndr_listitem(struct sd_buf *ob, const struct sd_buf *text, int flags, void *opaque)
 {
 	BUFPUTSL(ob, "<li>");
 	if (text) {
@@ -278,18 +278,18 @@ rndr_listitem(struct buf *ob, const struct buf *text, int flags, void *opaque)
 		while (size && text->data[size - 1] == '\n')
 			size--;
 
-		bufput(ob, text->data, size);
+		sd_bufput(ob, text->data, size);
 	}
 	BUFPUTSL(ob, "</li>\n");
 }
 
 static void
-rndr_paragraph(struct buf *ob, const struct buf *text, void *opaque)
+rndr_paragraph(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
-	struct html_renderopt *options = opaque;
+	struct sd_html_renderopt *options = opaque;
 	size_t i = 0;
 
-	if (ob->size) bufputc(ob, '\n');
+	if (ob->size) sd_bufputc(ob, '\n');
 
 	if (!text || !text->size)
 		return;
@@ -308,7 +308,7 @@ rndr_paragraph(struct buf *ob, const struct buf *text, void *opaque)
 				i++;
 
 			if (i > org)
-				bufput(ob, text->data + org, i - org);
+				sd_bufput(ob, text->data + org, i - org);
 
 			/*
 			 * do not insert a line break if this newline
@@ -321,13 +321,13 @@ rndr_paragraph(struct buf *ob, const struct buf *text, void *opaque)
 			i++;
 		}
 	} else {
-		bufput(ob, &text->data[i], text->size - i);
+		sd_bufput(ob, &text->data[i], text->size - i);
 	}
 	BUFPUTSL(ob, "</p>\n");
 }
 
 static void
-rndr_raw_block(struct buf *ob, const struct buf *text, void *opaque)
+rndr_raw_block(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
 	size_t org, sz;
 	if (!text) return;
@@ -336,33 +336,33 @@ rndr_raw_block(struct buf *ob, const struct buf *text, void *opaque)
 	org = 0;
 	while (org < sz && text->data[org] == '\n') org++;
 	if (org >= sz) return;
-	if (ob->size) bufputc(ob, '\n');
-	bufput(ob, text->data + org, sz - org);
-	bufputc(ob, '\n');
+	if (ob->size) sd_bufputc(ob, '\n');
+	sd_bufput(ob, text->data + org, sz - org);
+	sd_bufputc(ob, '\n');
 }
 
 static int
-rndr_triple_emphasis(struct buf *ob, const struct buf *text, void *opaque)
+rndr_triple_emphasis(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
 	if (!text || !text->size) return 0;
 	BUFPUTSL(ob, "<strong><em>");
-	bufput(ob, text->data, text->size);
+	sd_bufput(ob, text->data, text->size);
 	BUFPUTSL(ob, "</em></strong>");
 	return 1;
 }
 
 static void
-rndr_hrule(struct buf *ob, void *opaque)
+rndr_hrule(struct sd_buf *ob, void *opaque)
 {
-	struct html_renderopt *options = opaque;
-	if (ob->size) bufputc(ob, '\n');
-	bufputs(ob, USE_XHTML(options) ? "<hr/>\n" : "<hr>\n");
+	struct sd_html_renderopt *options = opaque;
+	if (ob->size) sd_bufputc(ob, '\n');
+	sd_bufputs(ob, USE_XHTML(options) ? "<hr/>\n" : "<hr>\n");
 }
 
 static int
-rndr_image(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *alt, void *opaque)
+rndr_image(struct sd_buf *ob, const struct sd_buf *link, const struct sd_buf *title, const struct sd_buf *alt, void *opaque)
 {
-	struct html_renderopt *options = opaque;
+	struct sd_html_renderopt *options = opaque;
 	if (!link || !link->size) return 0;
 
 	BUFPUTSL(ob, "<img src=\"");
@@ -376,14 +376,14 @@ rndr_image(struct buf *ob, const struct buf *link, const struct buf *title, cons
 		BUFPUTSL(ob, "\" title=\"");
 		escape_html(ob, title->data, title->size); }
 
-	bufputs(ob, USE_XHTML(options) ? "\"/>" : "\">");
+	sd_bufputs(ob, USE_XHTML(options) ? "\"/>" : "\">");
 	return 1;
 }
 
 static int
-rndr_raw_html(struct buf *ob, const struct buf *text, void *opaque)
+rndr_raw_html(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
-	struct html_renderopt *options = opaque;
+	struct sd_html_renderopt *options = opaque;
 
 	/* HTML_ESCAPE overrides SKIP_HTML, SKIP_STYLE, SKIP_LINKS and SKIP_IMAGES
 	* It doens't see if there are any valid tags, just escape all of them. */
@@ -396,45 +396,45 @@ rndr_raw_html(struct buf *ob, const struct buf *text, void *opaque)
 		return 1;
 
 	if ((options->flags & HTML_SKIP_STYLE) != 0 &&
-		sdhtml_is_tag(text->data, text->size, "style"))
+		sd_html_is_tag(text->data, text->size, "style"))
 		return 1;
 
 	if ((options->flags & HTML_SKIP_LINKS) != 0 &&
-		sdhtml_is_tag(text->data, text->size, "a"))
+		sd_html_is_tag(text->data, text->size, "a"))
 		return 1;
 
 	if ((options->flags & HTML_SKIP_IMAGES) != 0 &&
-		sdhtml_is_tag(text->data, text->size, "img"))
+		sd_html_is_tag(text->data, text->size, "img"))
 		return 1;
 
-	bufput(ob, text->data, text->size);
+	sd_bufput(ob, text->data, text->size);
 	return 1;
 }
 
 static void
-rndr_table(struct buf *ob, const struct buf *header, const struct buf *body, void *opaque)
+rndr_table(struct sd_buf *ob, const struct sd_buf *header, const struct sd_buf *body, void *opaque)
 {
-	if (ob->size) bufputc(ob, '\n');
+	if (ob->size) sd_bufputc(ob, '\n');
 	BUFPUTSL(ob, "<table><thead>\n");
 	if (header)
-		bufput(ob, header->data, header->size);
+		sd_bufput(ob, header->data, header->size);
 	BUFPUTSL(ob, "</thead><tbody>\n");
 	if (body)
-		bufput(ob, body->data, body->size);
+		sd_bufput(ob, body->data, body->size);
 	BUFPUTSL(ob, "</tbody></table>\n");
 }
 
 static void
-rndr_tablerow(struct buf *ob, const struct buf *text, void *opaque)
+rndr_tablerow(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
 	BUFPUTSL(ob, "<tr>\n");
 	if (text)
-		bufput(ob, text->data, text->size);
+		sd_bufput(ob, text->data, text->size);
 	BUFPUTSL(ob, "</tr>\n");
 }
 
 static void
-rndr_tablecell(struct buf *ob, const struct buf *text, int flags, void *opaque)
+rndr_tablecell(struct sd_buf *ob, const struct sd_buf *text, int flags, void *opaque)
 {
 	if (flags & MKD_TABLE_HEADER) {
 		BUFPUTSL(ob, "<th");
@@ -460,7 +460,7 @@ rndr_tablecell(struct buf *ob, const struct buf *text, int flags, void *opaque)
 	}
 
 	if (text)
-		bufput(ob, text->data, text->size);
+		sd_bufput(ob, text->data, text->size);
 
 	if (flags & MKD_TABLE_HEADER) {
 		BUFPUTSL(ob, "</th>\n");
@@ -470,26 +470,26 @@ rndr_tablecell(struct buf *ob, const struct buf *text, int flags, void *opaque)
 }
 
 static int
-rndr_superscript(struct buf *ob, const struct buf *text, void *opaque)
+rndr_superscript(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
 	if (!text || !text->size) return 0;
 	BUFPUTSL(ob, "<sup>");
-	bufput(ob, text->data, text->size);
+	sd_bufput(ob, text->data, text->size);
 	BUFPUTSL(ob, "</sup>");
 	return 1;
 }
 
 static void
-rndr_normal_text(struct buf *ob, const struct buf *text, void *opaque)
+rndr_normal_text(struct sd_buf *ob, const struct sd_buf *text, void *opaque)
 {
 	if (text)
 		escape_html(ob, text->data, text->size);
 }
 
 static void
-toc_header(struct buf *ob, const struct buf *text, int level, void *opaque)
+toc_header(struct sd_buf *ob, const struct sd_buf *text, int level, void *opaque)
 {
-	struct html_renderopt *options = opaque;
+	struct sd_html_renderopt *options = opaque;
 
 	/* set the level offset if this is the first header
 	 * we're parsing for the document */
@@ -514,24 +514,24 @@ toc_header(struct buf *ob, const struct buf *text, int level, void *opaque)
 		BUFPUTSL(ob,"</li>\n<li>\n");
 	}
 
-	bufprintf(ob, "<a href=\"#toc_%d\">", options->toc_data.header_count++);
+	sd_bufprintf(ob, "<a href=\"#toc_%d\">", options->toc_data.header_count++);
 	if (text)
 		escape_html(ob, text->data, text->size);
 	BUFPUTSL(ob, "</a>\n");
 }
 
 static int
-toc_link(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque)
+toc_link(struct sd_buf *ob, const struct sd_buf *link, const struct sd_buf *title, const struct sd_buf *content, void *opaque)
 {
 	if (content && content->size)
-		bufput(ob, content->data, content->size);
+		sd_bufput(ob, content->data, content->size);
 	return 1;
 }
 
 static void
-toc_finalize(struct buf *ob, void *opaque)
+toc_finalize(struct sd_buf *ob, void *opaque)
 {
-	struct html_renderopt *options = opaque;
+	struct sd_html_renderopt *options = opaque;
 
 	while (options->toc_data.current_level > 0) {
 		BUFPUTSL(ob, "</li>\n</ul>\n");
@@ -540,7 +540,7 @@ toc_finalize(struct buf *ob, void *opaque)
 }
 
 void
-sdhtml_toc_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options)
+sd_html_toc_renderer(struct sd_callbacks *callbacks, struct sd_html_renderopt *options)
 {
 	static const struct sd_callbacks cb_default = {
 		NULL,
@@ -574,14 +574,14 @@ sdhtml_toc_renderer(struct sd_callbacks *callbacks, struct html_renderopt *optio
 		toc_finalize,
 	};
 
-	memset(options, 0x0, sizeof(struct html_renderopt));
+	memset(options, 0x0, sizeof(struct sd_html_renderopt));
 	options->flags = HTML_TOC;
 
 	memcpy(callbacks, &cb_default, sizeof(struct sd_callbacks));
 }
 
 void
-sdhtml_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options, unsigned int render_flags)
+sd_html_renderer(struct sd_callbacks *callbacks, struct sd_html_renderopt *options, unsigned int render_flags)
 {
 	static const struct sd_callbacks cb_default = {
 		rndr_blockcode,
@@ -616,7 +616,7 @@ sdhtml_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options,
 	};
 
 	/* Prepare the options pointer */
-	memset(options, 0x0, sizeof(struct html_renderopt));
+	memset(options, 0x0, sizeof(struct sd_html_renderopt));
 	options->flags = render_flags;
 
 	/* Prepare the callbacks */
diff --git a/html/html.h b/html/html.h
index 4c8810d..5152caf 100644
--- a/html/html.h
+++ b/html/html.h
@@ -25,7 +25,7 @@
 extern "C" {
 #endif
 
-struct html_renderopt {
+struct sd_html_renderopt {
 	struct {
 		int header_count;
 		int current_level;
@@ -35,7 +35,7 @@ struct html_renderopt {
 	unsigned int flags;
 
 	/* extra callbacks */
-	void (*link_attributes)(struct buf *ob, const struct buf *url, void *self);
+	void (*link_attributes)(struct sd_buf *ob, const struct sd_buf *url, void *self);
 };
 
 typedef enum {
@@ -49,7 +49,7 @@ typedef enum {
 	HTML_HARD_WRAP = (1 << 7),
 	HTML_USE_XHTML = (1 << 8),
 	HTML_ESCAPE = (1 << 9),
-} html_render_mode;
+} sd_html_render_mode;
 
 typedef enum {
 	HTML_TAG_NONE = 0,
@@ -58,16 +58,16 @@ typedef enum {
 } html_tag;
 
 int
-sdhtml_is_tag(const uint8_t *tag_data, size_t tag_size, const char *tagname);
+sd_html_is_tag(const uint8_t *tag_data, size_t tag_size, const char *tagname);
 
 extern void
-sdhtml_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options_ptr, unsigned int render_flags);
+sd_html_renderer(struct sd_callbacks *callbacks, struct sd_html_renderopt *options_ptr, unsigned int render_flags);
 
 extern void
-sdhtml_toc_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options_ptr);
+sd_html_toc_renderer(struct sd_callbacks *callbacks, struct sd_html_renderopt *options_ptr);
 
 extern void
-sdhtml_smartypants(struct buf *ob, const uint8_t *text, size_t size);
+sd_html_smartypants(struct sd_buf *ob, const uint8_t *text, size_t size);
 
 #ifdef __cplusplus
 }
diff --git a/html/html_smartypants.c b/html/html_smartypants.c
index 367c26a..d7de747 100644
--- a/html/html_smartypants.c
+++ b/html/html_smartypants.c
@@ -31,19 +31,19 @@ struct smartypants_data {
 	int in_dquote;
 };
 
-static size_t smartypants_cb__ltag(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
-static size_t smartypants_cb__dquote(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
-static size_t smartypants_cb__amp(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
-static size_t smartypants_cb__period(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
-static size_t smartypants_cb__number(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
-static size_t smartypants_cb__dash(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
-static size_t smartypants_cb__parens(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
-static size_t smartypants_cb__squote(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
-static size_t smartypants_cb__backtick(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
-static size_t smartypants_cb__escape(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
+static size_t smartypants_cb__ltag(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
+static size_t smartypants_cb__dquote(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
+static size_t smartypants_cb__amp(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
+static size_t smartypants_cb__period(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
+static size_t smartypants_cb__number(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
+static size_t smartypants_cb__dash(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
+static size_t smartypants_cb__parens(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
+static size_t smartypants_cb__squote(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
+static size_t smartypants_cb__backtick(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
+static size_t smartypants_cb__escape(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size);
 
 static size_t (*smartypants_cb_ptrs[])
-	(struct buf *, struct smartypants_data *, uint8_t, const uint8_t *, size_t) =
+	(struct sd_buf *, struct smartypants_data *, uint8_t, const uint8_t *, size_t) =
 {
 	NULL,					/* 0 */
 	smartypants_cb__dash,	/* 1 */
@@ -84,7 +84,7 @@ word_boundary(uint8_t c)
 }
 
 static int
-smartypants_quotes(struct buf *ob, uint8_t previous_char, uint8_t next_char, uint8_t quote, int *is_open)
+smartypants_quotes(struct sd_buf *ob, uint8_t previous_char, uint8_t next_char, uint8_t quote, int *is_open)
 {
 	char ent[8];
 
@@ -96,12 +96,12 @@ smartypants_quotes(struct buf *ob, uint8_t previous_char, uint8_t next_char, uin
 
 	snprintf(ent, sizeof(ent), "&%c%cquo;", (*is_open) ? 'r' : 'l', quote);
 	*is_open = !(*is_open);
-	bufputs(ob, ent);
+	sd_bufputs(ob, ent);
 	return 1;
 }
 
 static size_t
-smartypants_cb__squote(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
+smartypants_cb__squote(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
 {
 	if (size >= 2) {
 		uint8_t t1 = tolower(text[1]);
@@ -133,12 +133,12 @@ smartypants_cb__squote(struct buf *ob, struct smartypants_data *smrt, uint8_t pr
 	if (smartypants_quotes(ob, previous_char, size > 0 ? text[1] : 0, 's', &smrt->in_squote))
 		return 0;
 
-	bufputc(ob, text[0]);
+	sd_bufputc(ob, text[0]);
 	return 0;
 }
 
 static size_t
-smartypants_cb__parens(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
+smartypants_cb__parens(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
 {
 	if (size >= 3) {
 		uint8_t t1 = tolower(text[1]);
@@ -160,12 +160,12 @@ smartypants_cb__parens(struct buf *ob, struct smartypants_data *smrt, uint8_t pr
 		}
 	}
 
-	bufputc(ob, text[0]);
+	sd_bufputc(ob, text[0]);
 	return 0;
 }
 
 static size_t
-smartypants_cb__dash(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
+smartypants_cb__dash(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
 {
 	if (size >= 3 && text[1] == '-' && text[2] == '-') {
 		BUFPUTSL(ob, "&mdash;");
@@ -177,12 +177,12 @@ smartypants_cb__dash(struct buf *ob, struct smartypants_data *smrt, uint8_t prev
 		return 1;
 	}
 
-	bufputc(ob, text[0]);
+	sd_bufputc(ob, text[0]);
 	return 0;
 }
 
 static size_t
-smartypants_cb__amp(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
+smartypants_cb__amp(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
 {
 	if (size >= 6 && memcmp(text, "&quot;", 6) == 0) {
 		if (smartypants_quotes(ob, previous_char, size >= 7 ? text[6] : 0, 'd', &smrt->in_dquote))
@@ -192,12 +192,12 @@ smartypants_cb__amp(struct buf *ob, struct smartypants_data *smrt, uint8_t previ
 	if (size >= 4 && memcmp(text, "&#0;", 4) == 0)
 		return 3;
 
-	bufputc(ob, '&');
+	sd_bufputc(ob, '&');
 	return 0;
 }
 
 static size_t
-smartypants_cb__period(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
+smartypants_cb__period(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
 {
 	if (size >= 3 && text[1] == '.' && text[2] == '.') {
 		BUFPUTSL(ob, "&hellip;");
@@ -209,12 +209,12 @@ smartypants_cb__period(struct buf *ob, struct smartypants_data *smrt, uint8_t pr
 		return 4;
 	}
 
-	bufputc(ob, text[0]);
+	sd_bufputc(ob, text[0]);
 	return 0;
 }
 
 static size_t
-smartypants_cb__backtick(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
+smartypants_cb__backtick(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
 {
 	if (size >= 2 && text[1] == '`') {
 		if (smartypants_quotes(ob, previous_char, size >= 3 ? text[2] : 0, 'd', &smrt->in_dquote))
@@ -225,7 +225,7 @@ smartypants_cb__backtick(struct buf *ob, struct smartypants_data *smrt, uint8_t
 }
 
 static size_t
-smartypants_cb__number(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
+smartypants_cb__number(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
 {
 	if (word_boundary(previous_char) && size >= 3) {
 		if (text[0] == '1' && text[1] == '/' && text[2] == '2') {
@@ -252,12 +252,12 @@ smartypants_cb__number(struct buf *ob, struct smartypants_data *smrt, uint8_t pr
 		}
 	}
 
-	bufputc(ob, text[0]);
+	sd_bufputc(ob, text[0]);
 	return 0;
 }
 
 static size_t
-smartypants_cb__dquote(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
+smartypants_cb__dquote(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
 {
 	if (!smartypants_quotes(ob, previous_char, size > 0 ? text[1] : 0, 'd', &smrt->in_dquote))
 		BUFPUTSL(ob, "&quot;");
@@ -266,7 +266,7 @@ smartypants_cb__dquote(struct buf *ob, struct smartypants_data *smrt, uint8_t pr
 }
 
 static size_t
-smartypants_cb__ltag(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
+smartypants_cb__ltag(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
 {
 	static const char *skip_tags[] = {
 	  "pre", "code", "var", "samp", "kbd", "math", "script", "style"
@@ -279,7 +279,7 @@ smartypants_cb__ltag(struct buf *ob, struct smartypants_data *smrt, uint8_t prev
 		i++;
 
 	for (tag = 0; tag < skip_tags_count; ++tag) {
-		if (sdhtml_is_tag(text, size, skip_tags[tag]) == HTML_TAG_OPEN)
+		if (sd_html_is_tag(text, size, skip_tags[tag]) == HTML_TAG_OPEN)
 			break;
 	}
 
@@ -291,7 +291,7 @@ smartypants_cb__ltag(struct buf *ob, struct smartypants_data *smrt, uint8_t prev
 			if (i == size)
 				break;
 
-			if (sdhtml_is_tag(text + i, size - i, skip_tags[tag]) == HTML_TAG_CLOSE)
+			if (sd_html_is_tag(text + i, size - i, skip_tags[tag]) == HTML_TAG_CLOSE)
 				break;
 
 			i++;
@@ -301,12 +301,12 @@ smartypants_cb__ltag(struct buf *ob, struct smartypants_data *smrt, uint8_t prev
 			i++;
 	}
 
-	bufput(ob, text, i + 1);
+	sd_bufput(ob, text, i + 1);
 	return i;
 }
 
 static size_t
-smartypants_cb__escape(struct buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
+smartypants_cb__escape(struct sd_buf *ob, struct smartypants_data *smrt, uint8_t previous_char, const uint8_t *text, size_t size)
 {
 	if (size < 2)
 		return 0;
@@ -318,11 +318,11 @@ smartypants_cb__escape(struct buf *ob, struct smartypants_data *smrt, uint8_t pr
 	case '.':
 	case '-':
 	case '`':
-		bufputc(ob, text[1]);
+		sd_bufputc(ob, text[1]);
 		return 1;
 
 	default:
-		bufputc(ob, '\\');
+		sd_bufputc(ob, '\\');
 		return 0;
 	}
 }
@@ -358,7 +358,7 @@ static struct {
 #endif
 
 void
-sdhtml_smartypants(struct buf *ob, const uint8_t *text, size_t size)
+sd_html_smartypants(struct sd_buf *ob, const uint8_t *text, size_t size)
 {
 	size_t i;
 	struct smartypants_data smrt = {0, 0};
@@ -366,7 +366,7 @@ sdhtml_smartypants(struct buf *ob, const uint8_t *text, size_t size)
 	if (!text)
 		return;
 
-	bufgrow(ob, size);
+	sd_bufgrow(ob, size);
 
 	for (i = 0; i < size; ++i) {
 		size_t org;
@@ -377,7 +377,7 @@ sdhtml_smartypants(struct buf *ob, const uint8_t *text, size_t size)
 			i++;
 
 		if (i > org)
-			bufput(ob, text + org, i - org);
+			sd_bufput(ob, text + org, i - org);
 
 		if (i < size) {
 			i += smartypants_cb_ptrs[(int)action]
diff --git a/sdcdefs.lua b/sdcdefs.lua
index 71331ca..2d20736 100644
--- a/sdcdefs.lua
+++ b/sdcdefs.lua
@@ -80,4 +80,17 @@ void sd_markdown_free(struct sd_markdown *md);
 
 void sd_version(int *major, int *minor, int *revision);
 
+/* buffer */
+
+int sd_bufgrow(struct sd_buf *, size_t);
+struct sd_buf *sd_bufnew(size_t) __attribute__ ((malloc));
+const char *sd_bufcstr(struct sd_buf *);
+int sd_bufprefix(const struct sd_buf *buf, const char *prefix);
+void sd_bufput(struct sd_buf *, const void *, size_t);
+void sd_bufputs(struct sd_buf *, const char *);
+void sd_bufputc(struct sd_buf *, int);
+void sd_bufrelease(struct sd_buf *);
+void sd_bufreset(struct sd_buf *);
+void sd_bufslurp(struct sd_buf *, size_t);
+
 ]]
diff --git a/src/autolink.c b/src/autolink.c
index 6f8d6ab..5359497 100644
--- a/src/autolink.c
+++ b/src/autolink.c
@@ -161,7 +161,7 @@ check_domain(uint8_t *data, size_t size, int allow_short)
 size_t
 sd_autolink__www(
 	size_t *rewind_p,
-	struct buf *link,
+	struct sd_buf *link,
 	uint8_t *data,
 	size_t max_rewind,
 	size_t size,
@@ -188,7 +188,7 @@ sd_autolink__www(
 	if (link_end == 0)
 		return 0;
 
-	bufput(link, data, link_end);
+	sd_bufput(link, data, link_end);
 	*rewind_p = 0;
 
 	return (int)link_end;
@@ -197,7 +197,7 @@ sd_autolink__www(
 size_t
 sd_autolink__email(
 	size_t *rewind_p,
-	struct buf *link,
+	struct sd_buf *link,
 	uint8_t *data,
 	size_t max_rewind,
 	size_t size,
@@ -244,7 +244,7 @@ sd_autolink__email(
 	if (link_end == 0)
 		return 0;
 
-	bufput(link, data - rewind, link_end + rewind);
+	sd_bufput(link, data - rewind, link_end + rewind);
 	*rewind_p = rewind;
 
 	return link_end;
@@ -253,7 +253,7 @@ sd_autolink__email(
 size_t
 sd_autolink__url(
 	size_t *rewind_p,
-	struct buf *link,
+	struct sd_buf *link,
 	uint8_t *data,
 	size_t max_rewind,
 	size_t size,
@@ -289,7 +289,7 @@ sd_autolink__url(
 	if (link_end == 0)
 		return 0;
 
-	bufput(link, data - rewind, link_end + rewind);
+	sd_bufput(link, data - rewind, link_end + rewind);
 	*rewind_p = rewind;
 
 	return link_end;
diff --git a/src/autolink.h b/src/autolink.h
index 65e0fe6..dc5b723 100644
--- a/src/autolink.h
+++ b/src/autolink.h
@@ -31,15 +31,15 @@ int
 sd_autolink_issafe(const uint8_t *link, size_t link_len);
 
 size_t
-sd_autolink__www(size_t *rewind_p, struct buf *link,
+sd_autolink__www(size_t *rewind_p, struct sd_buf *link,
 	uint8_t *data, size_t offset, size_t size, unsigned int flags);
 
 size_t
-sd_autolink__email(size_t *rewind_p, struct buf *link,
+sd_autolink__email(size_t *rewind_p, struct sd_buf *link,
 	uint8_t *data, size_t offset, size_t size, unsigned int flags);
 
 size_t
-sd_autolink__url(size_t *rewind_p, struct buf *link,
+sd_autolink__url(size_t *rewind_p, struct sd_buf *link,
 	uint8_t *data, size_t offset, size_t size, unsigned int flags);
 
 #ifdef __cplusplus
diff --git a/src/buffer.c b/src/buffer.c
index 47b40ce..519b231 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -26,63 +26,63 @@
 
 /* MSVC compat */
 #if defined(_MSC_VER)
-#	define _buf_vsnprintf _vsnprintf
+#	define _sd_buf_vsnprintf _vsnprintf
 #else
-#	define _buf_vsnprintf vsnprintf
+#	define _sd_buf_vsnprintf vsnprintf
 #endif
 
 int
-bufprefix(const struct buf *buf, const char *prefix)
+sd_bufprefix(const struct sd_buf *sd_buf, const char *prefix)
 {
 	size_t i;
-	assert(buf && buf->unit);
+	assert(sd_buf && sd_buf->unit);
 
-	for (i = 0; i < buf->size; ++i) {
+	for (i = 0; i < sd_buf->size; ++i) {
 		if (prefix[i] == 0)
 			return 0;
 
-		if (buf->data[i] != prefix[i])
-			return buf->data[i] - prefix[i];
+		if (sd_buf->data[i] != prefix[i])
+			return sd_buf->data[i] - prefix[i];
 	}
 
 	return 0;
 }
 
-/* bufgrow: increasing the allocated size to the given value */
+/* sd_bufgrow: increasing the allocated size to the given value */
 int
-bufgrow(struct buf *buf, size_t neosz)
+sd_bufgrow(struct sd_buf *sd_buf, size_t neosz)
 {
 	size_t neoasz;
 	void *neodata;
 
-	assert(buf && buf->unit);
+	assert(sd_buf && sd_buf->unit);
 
 	if (neosz > BUFFER_MAX_ALLOC_SIZE)
 		return BUF_ENOMEM;
 
-	if (buf->asize >= neosz)
+	if (sd_buf->asize >= neosz)
 		return BUF_OK;
 
-	neoasz = buf->asize + buf->unit;
+	neoasz = sd_buf->asize + sd_buf->unit;
 	while (neoasz < neosz)
-		neoasz += buf->unit;
+		neoasz += sd_buf->unit;
 
-	neodata = realloc(buf->data, neoasz);
+	neodata = realloc(sd_buf->data, neoasz);
 	if (!neodata)
 		return BUF_ENOMEM;
 
-	buf->data = neodata;
-	buf->asize = neoasz;
+	sd_buf->data = neodata;
+	sd_buf->asize = neoasz;
 	return BUF_OK;
 }
 
 
-/* bufnew: allocation of a new buffer */
-struct buf *
-bufnew(size_t unit)
+/* sd_bufnew: allocation of a new buffer */
+struct sd_buf *
+sd_bufnew(size_t unit)
 {
-	struct buf *ret;
-	ret = malloc(sizeof (struct buf));
+	struct sd_buf *ret;
+	ret = malloc(sizeof (struct sd_buf));
 
 	if (ret) {
 		ret->data = 0;
@@ -92,37 +92,37 @@ bufnew(size_t unit)
 	return ret;
 }
 
-/* bufnullterm: NULL-termination of the string array */
+/* sd_bufnullterm: NULL-termination of the string array */
 const char *
-bufcstr(struct buf *buf)
+sd_bufcstr(struct sd_buf *sd_buf)
 {
-	assert(buf && buf->unit);
+	assert(sd_buf && sd_buf->unit);
 
-	if (buf->size < buf->asize && buf->data[buf->size] == 0)
-		return (char *)buf->data;
+	if (sd_buf->size < sd_buf->asize && sd_buf->data[sd_buf->size] == 0)
+		return (char *)sd_buf->data;
 
-	if (buf->size + 1 <= buf->asize || bufgrow(buf, buf->size + 1) == 0) {
-		buf->data[buf->size] = 0;
-		return (char *)buf->data;
+	if (sd_buf->size + 1 <= sd_buf->asize || sd_bufgrow(sd_buf, sd_buf->size + 1) == 0) {
+		sd_buf->data[sd_buf->size] = 0;
+		return (char *)sd_buf->data;
 	}
 
 	return NULL;
 }
 
-/* bufprintf: formatted printing to a buffer */
+/* sd_bufprintf: formatted printing to a buffer */
 void
-bufprintf(struct buf *buf, const char *fmt, ...)
+sd_bufprintf(struct sd_buf *sd_buf, const char *fmt, ...)
 {
 	va_list ap;
 	int n;
 
-	assert(buf && buf->unit);
+	assert(sd_buf && sd_buf->unit);
 
-	if (buf->size >= buf->asize && bufgrow(buf, buf->size + 1) < 0)
+	if (sd_buf->size >= sd_buf->asize && sd_bufgrow(sd_buf, sd_buf->size + 1) < 0)
 		return;
 	
 	va_start(ap, fmt);
-	n = _buf_vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
+	n = _sd_buf_vsnprintf((char *)sd_buf->data + sd_buf->size, sd_buf->asize - sd_buf->size, fmt, ap);
 	va_end(ap);
 
 	if (n < 0) {
@@ -135,91 +135,91 @@ bufprintf(struct buf *buf, const char *fmt, ...)
 #endif
 	}
 
-	if ((size_t)n >= buf->asize - buf->size) {
-		if (bufgrow(buf, buf->size + n + 1) < 0)
+	if ((size_t)n >= sd_buf->asize - sd_buf->size) {
+		if (sd_bufgrow(sd_buf, sd_buf->size + n + 1) < 0)
 			return;
 
 		va_start(ap, fmt);
-		n = _buf_vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
+		n = _sd_buf_vsnprintf((char *)sd_buf->data + sd_buf->size, sd_buf->asize - sd_buf->size, fmt, ap);
 		va_end(ap);
 	}
 
 	if (n < 0)
 		return;
 
-	buf->size += n;
+	sd_buf->size += n;
 }
 
-/* bufput: appends raw data to a buffer */
+/* sd_bufput: appends raw data to a buffer */
 void
-bufput(struct buf *buf, const void *data, size_t len)
+sd_bufput(struct sd_buf *sd_buf, const void *data, size_t len)
 {
-	assert(buf && buf->unit);
+	assert(sd_buf && sd_buf->unit);
 
-	if (buf->size + len > buf->asize && bufgrow(buf, buf->size + len) < 0)
+	if (sd_buf->size + len > sd_buf->asize && sd_bufgrow(sd_buf, sd_buf->size + len) < 0)
 		return;
 
-	memcpy(buf->data + buf->size, data, len);
-	buf->size += len;
+	memcpy(sd_buf->data + sd_buf->size, data, len);
+	sd_buf->size += len;
 }
 
-/* bufputs: appends a NUL-terminated string to a buffer */
+/* sd_bufputs: appends a NUL-terminated string to a buffer */
 void
-bufputs(struct buf *buf, const char *str)
+sd_bufputs(struct sd_buf *sd_buf, const char *str)
 {
-	bufput(buf, str, strlen(str));
+	sd_bufput(sd_buf, str, strlen(str));
 }
 
 
-/* bufputc: appends a single uint8_t to a buffer */
+/* sd_bufputc: appends a single uint8_t to a buffer */
 void
-bufputc(struct buf *buf, int c)
+sd_bufputc(struct sd_buf *sd_buf, int c)
 {
-	assert(buf && buf->unit);
+	assert(sd_buf && sd_buf->unit);
 
-	if (buf->size + 1 > buf->asize && bufgrow(buf, buf->size + 1) < 0)
+	if (sd_buf->size + 1 > sd_buf->asize && sd_bufgrow(sd_buf, sd_buf->size + 1) < 0)
 		return;
 
-	buf->data[buf->size] = c;
-	buf->size += 1;
+	sd_buf->data[sd_buf->size] = c;
+	sd_buf->size += 1;
 }
 
-/* bufrelease: decrease the reference count and free the buffer if needed */
+/* sd_bufrelease: decrease the reference count and free the buffer if needed */
 void
-bufrelease(struct buf *buf)
+sd_bufrelease(struct sd_buf *sd_buf)
 {
-	if (!buf)
+	if (!sd_buf)
 		return;
 
-	free(buf->data);
-	free(buf);
+	free(sd_buf->data);
+	free(sd_buf);
 }
 
 
-/* bufreset: frees internal data of the buffer */
+/* sd_bufreset: frees internal data of the buffer */
 void
-bufreset(struct buf *buf)
+sd_bufreset(struct sd_buf *sd_buf)
 {
-	if (!buf)
+	if (!sd_buf)
 		return;
 
-	free(buf->data);
-	buf->data = NULL;
-	buf->size = buf->asize = 0;
+	free(sd_buf->data);
+	sd_buf->data = NULL;
+	sd_buf->size = sd_buf->asize = 0;
 }
 
-/* bufslurp: removes a given number of bytes from the head of the array */
+/* sd_bufslurp: removes a given number of bytes from the head of the array */
 void
-bufslurp(struct buf *buf, size_t len)
+sd_bufslurp(struct sd_buf *sd_buf, size_t len)
 {
-	assert(buf && buf->unit);
+	assert(sd_buf && sd_buf->unit);
 
-	if (len >= buf->size) {
-		buf->size = 0;
+	if (len >= sd_buf->size) {
+		sd_buf->size = 0;
 		return;
 	}
 
-	buf->size -= len;
-	memmove(buf->data, buf->data + len, buf->size);
+	sd_buf->size -= len;
+	memmove(sd_buf->data, sd_buf->data + len, sd_buf->size);
 }
 
diff --git a/src/buffer.h b/src/buffer.h
index 221d142..3b45600 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -34,10 +34,10 @@ extern "C" {
 typedef enum {
 	BUF_OK = 0,
 	BUF_ENOMEM = -1,
-} buferror_t;
+} sd_buferror_t;
 
-/* struct buf: character array buffer */
-struct buf {
+/* struct sd_buf: character array buffer */
+struct sd_buf {
 	uint8_t *data;		/* actual character data */
 	size_t size;	/* size of the string */
 	size_t asize;	/* allocated size (0 = volatile buffer) */
@@ -54,40 +54,40 @@ struct buf {
 
 /* BUFPUTSL: optimized bufputs of a string litteral */
 #define BUFPUTSL(output, literal) \
-	bufput(output, literal, sizeof literal - 1)
+	sd_bufput(output, literal, sizeof literal - 1)
 
 /* bufgrow: increasing the allocated size to the given value */
-int bufgrow(struct buf *, size_t);
+int sd_bufgrow(struct sd_buf *, size_t);
 
 /* bufnew: allocation of a new buffer */
-struct buf *bufnew(size_t) __attribute__ ((malloc));
+struct sd_buf *sd_bufnew(size_t) __attribute__ ((malloc));
 
 /* bufnullterm: NUL-termination of the string array (making a C-string) */
-const char *bufcstr(struct buf *);
+const char *sd_bufcstr(struct sd_buf *);
 
 /* bufprefix: compare the beginning of a buffer with a string */
-int bufprefix(const struct buf *buf, const char *prefix);
+int sd_bufprefix(const struct sd_buf *buf, const char *prefix);
 
 /* bufput: appends raw data to a buffer */
-void bufput(struct buf *, const void *, size_t);
+void sd_bufput(struct sd_buf *, const void *, size_t);
 
 /* bufputs: appends a NUL-terminated string to a buffer */
-void bufputs(struct buf *, const char *);
+void sd_bufputs(struct sd_buf *, const char *);
 
 /* bufputc: appends a single char to a buffer */
-void bufputc(struct buf *, int);
+void sd_bufputc(struct sd_buf *, int);
 
 /* bufrelease: decrease the reference count and free the buffer if needed */
-void bufrelease(struct buf *);
+void sd_bufrelease(struct sd_buf *);
 
 /* bufreset: frees internal data of the buffer */
-void bufreset(struct buf *);
+void sd_bufreset(struct sd_buf *);
 
 /* bufslurp: removes a given number of bytes from the head of the array */
-void bufslurp(struct buf *, size_t);
+void sd_bufslurp(struct sd_buf *, size_t);
 
 /* bufprintf: formatted printing to a buffer */
-void bufprintf(struct buf *, const char *, ...) __attribute__ ((format (printf, 2, 3)));
+void sd_bufprintf(struct sd_buf *, const char *, ...) __attribute__ ((format (printf, 2, 3)));
 
 #ifdef __cplusplus
 }
diff --git a/src/html_blocks.h b/src/html_blocks.h
index 09a758f..dcd2331 100644
--- a/src/html_blocks.h
+++ b/src/html_blocks.h
@@ -87,7 +87,7 @@ inline
 #endif
 #endif
 static unsigned int
-hash_block_tag (str, len)
+sd_hash_block_tag (str, len)
      register const char *str;
      register unsigned int len;
 {
@@ -141,7 +141,7 @@ __attribute__ ((__gnu_inline__))
 #endif
 #endif
 const char *
-find_block_tag (str, len)
+sd_find_block_tag (str, len)
      register const char *str;
      register unsigned int len;
 {
@@ -192,7 +192,7 @@ find_block_tag (str, len)
 
   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
     {
-      register int key = hash_block_tag (str, len);
+      register int key = sd_hash_block_tag (str, len);
 
       if (key <= MAX_HASH_VALUE && key >= 0)
         {
diff --git a/src/markdown.c b/src/markdown.c
index ea3cf23..7965b44 100644
--- a/src/markdown.c
+++ b/src/markdown.c
@@ -49,8 +49,8 @@
 struct link_ref {
 	unsigned int id;
 
-	struct buf *link;
-	struct buf *title;
+	struct sd_buf *link;
+	struct sd_buf *title;
 
 	struct link_ref *next;
 };
@@ -61,19 +61,19 @@ struct link_ref {
 /*   offset is the number of valid chars before data */
 struct sd_markdown;
 typedef size_t
-(*char_trigger)(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
-
-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_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);
-static size_t char_entity(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
-static size_t char_langle_tag(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
-static size_t char_autolink_url(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
-static size_t char_autolink_email(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
-static size_t char_autolink_www(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
-static size_t char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
-static size_t char_superscript(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+(*char_trigger)(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+
+static size_t char_emphasis(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_linebreak(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_codespan(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_escape(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_entity(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_langle_tag(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_autolink_url(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_autolink_email(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_autolink_www(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_link(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_superscript(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
 
 enum markdown_char_t {
 	MD_CHAR_NONE = 0,
@@ -112,7 +112,7 @@ struct sd_markdown {
 
 	struct link_ref *refs[REF_TABLE_SIZE];
 	uint8_t active_char[256];
-	struct stack work_bufs[2];
+	struct sd_stack work_sd_bufs[2];
 	unsigned int ext_flags;
 	size_t max_nesting;
 	int in_link_body;
@@ -122,33 +122,33 @@ struct sd_markdown {
  * HELPER FUNCTIONS *
  ***************************/
 
-static inline struct buf *
-rndr_newbuf(struct sd_markdown *rndr, int type)
+static inline struct sd_buf *
+rndr_newsd_buf(struct sd_markdown *rndr, int type)
 {
-	static const size_t buf_size[2] = {256, 64};
-	struct buf *work = NULL;
-	struct stack *pool = &rndr->work_bufs[type];
+	static const size_t sd_buf_size[2] = {256, 64};
+	struct sd_buf *work = NULL;
+	struct sd_stack *pool = &rndr->work_sd_bufs[type];
 
 	if (pool->size < pool->asize &&
 		pool->item[pool->size] != NULL) {
 		work = pool->item[pool->size++];
 		work->size = 0;
 	} else {
-		work = bufnew(buf_size[type]);
-		stack_push(pool, work);
+		work = sd_bufnew(sd_buf_size[type]);
+		sd_stack_push(pool, work);
 	}
 
 	return work;
 }
 
 static inline void
-rndr_popbuf(struct sd_markdown *rndr, int type)
+rndr_popsd_buf(struct sd_markdown *rndr, int type)
 {
-	rndr->work_bufs[type].size--;
+	rndr->work_sd_bufs[type].size--;
 }
 
 static void
-unscape_text(struct buf *ob, struct buf *src)
+unscape_text(struct sd_buf *ob, struct sd_buf *src)
 {
 	size_t i = 0, org;
 	while (i < src->size) {
@@ -157,12 +157,12 @@ unscape_text(struct buf *ob, struct buf *src)
 			i++;
 
 		if (i > org)
-			bufput(ob, src->data + org, i - org);
+			sd_bufput(ob, src->data + org, i - org);
 
 		if (i + 1 >= src->size)
 			break;
 
-		bufputc(ob, src->data[i + 1]);
+		sd_bufputc(ob, src->data[i + 1]);
 		i += 2;
 	}
 }
@@ -225,8 +225,8 @@ free_link_refs(struct link_ref **references)
 
 		while (r) {
 			next = r->next;
-			bufrelease(r->link);
-			bufrelease(r->title);
+			sd_bufrelease(r->link);
+			sd_bufrelease(r->title);
 			free(r);
 			r = next;
 		}
@@ -288,7 +288,7 @@ is_mail_autolink(uint8_t *data, size_t size)
 
 /* tag_length • returns the length of the given tag, or 0 is it's not valid */
 static size_t
-tag_length(uint8_t *data, size_t size, enum mkd_autolink *autolink)
+tag_length(uint8_t *data, size_t size, enum sd_mkd_autolink *autolink)
 {
 	size_t i, j;
 
@@ -350,14 +350,14 @@ tag_length(uint8_t *data, size_t size, enum mkd_autolink *autolink)
 
 /* parse_inline • parses inline markdown elements */
 static void
-parse_inline(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
+parse_inline(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t i = 0, end = 0;
 	uint8_t action = 0;
-	struct buf work = { 0, 0, 0, 0 };
+	struct sd_buf work = { 0, 0, 0, 0 };
 
-	if (rndr->work_bufs[BUFFER_SPAN].size +
-		rndr->work_bufs[BUFFER_BLOCK].size > rndr->max_nesting)
+	if (rndr->work_sd_bufs[BUFFER_SPAN].size +
+		rndr->work_sd_bufs[BUFFER_BLOCK].size > rndr->max_nesting)
 		return;
 
 	while (i < size) {
@@ -372,7 +372,7 @@ parse_inline(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t siz
 			rndr->cb.normal_text(ob, &work, rndr->opaque);
 		}
 		else
-			bufput(ob, data + i, end - i);
+			sd_bufput(ob, data + i, end - i);
 
 		if (end >= size) break;
 		i = end;
@@ -481,10 +481,10 @@ find_emph_char(uint8_t *data, size_t size, uint8_t c)
 /* parse_emph1 • parsing single emphase */
 /* closed by a symbol not preceded by whitespace and not followed by symbol */
 static size_t
-parse_emph1(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c)
+parse_emph1(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c)
 {
 	size_t i = 0, len;
-	struct buf *work = 0;
+	struct sd_buf *work = 0;
 	int r;
 
 	if (!rndr->cb.emphasis) return 0;
@@ -505,10 +505,10 @@ parse_emph1(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size
 					continue;
 			}
 
-			work = rndr_newbuf(rndr, BUFFER_SPAN);
+			work = rndr_newsd_buf(rndr, BUFFER_SPAN);
 			parse_inline(work, rndr, data, i);
 			r = rndr->cb.emphasis(ob, work, rndr->opaque);
-			rndr_popbuf(rndr, BUFFER_SPAN);
+			rndr_popsd_buf(rndr, BUFFER_SPAN);
 			return r ? i + 1 : 0;
 		}
 	}
@@ -518,11 +518,11 @@ parse_emph1(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size
 
 /* parse_emph2 • parsing single emphase */
 static size_t
-parse_emph2(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c)
+parse_emph2(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c)
 {
-	int (*render_method)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*render_method)(struct sd_buf *ob, const struct sd_buf *text, void *opaque);
 	size_t i = 0, len;
-	struct buf *work = 0;
+	struct sd_buf *work = 0;
 	int r;
 
 	render_method = (c == '~') ? rndr->cb.strikethrough : rndr->cb.double_emphasis;
@@ -536,10 +536,10 @@ parse_emph2(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size
 		i += len;
 
 		if (i + 1 < size && data[i] == c && data[i + 1] == c && i && !_isspace(data[i - 1])) {
-			work = rndr_newbuf(rndr, BUFFER_SPAN);
+			work = rndr_newsd_buf(rndr, BUFFER_SPAN);
 			parse_inline(work, rndr, data, i);
 			r = render_method(ob, work, rndr->opaque);
-			rndr_popbuf(rndr, BUFFER_SPAN);
+			rndr_popsd_buf(rndr, BUFFER_SPAN);
 			return r ? i + 2 : 0;
 		}
 		i++;
@@ -550,7 +550,7 @@ parse_emph2(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size
 /* parse_emph3 • parsing single emphase */
 /* finds the first closing tag, and delegates to the other emph */
 static size_t
-parse_emph3(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c)
+parse_emph3(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c)
 {
 	size_t i = 0, len;
 	int r;
@@ -566,11 +566,11 @@ parse_emph3(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size
 
 		if (i + 2 < size && data[i + 1] == c && data[i + 2] == c && rndr->cb.triple_emphasis) {
 			/* triple symbol found */
-			struct buf *work = rndr_newbuf(rndr, BUFFER_SPAN);
+			struct sd_buf *work = rndr_newsd_buf(rndr, BUFFER_SPAN);
 
 			parse_inline(work, rndr, data, i);
 			r = rndr->cb.triple_emphasis(ob, work, rndr->opaque);
-			rndr_popbuf(rndr, BUFFER_SPAN);
+			rndr_popsd_buf(rndr, BUFFER_SPAN);
 			return r ? i + 3 : 0;
 
 		} else if (i + 1 < size && data[i + 1] == c) {
@@ -591,7 +591,7 @@ parse_emph3(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size
 
 /* char_emphasis • single and double emphasis parsing */
 static size_t
-char_emphasis(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_emphasis(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	uint8_t c = data[0];
 	size_t ret;
@@ -630,7 +630,7 @@ char_emphasis(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t of
 
 /* char_linebreak • '\n' preceded by two spaces (assuming linebreak != 0) */
 static size_t
-char_linebreak(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_linebreak(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	if (offset < 2 || data[-1] != ' ' || data[-2] != ' ')
 		return 0;
@@ -645,7 +645,7 @@ char_linebreak(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t o
 
 /* char_codespan • '`' parsing a code span (assuming codespan != 0) */
 static size_t
-char_codespan(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_codespan(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	size_t end, nb = 0, i, f_begin, f_end;
 
@@ -674,7 +674,7 @@ char_codespan(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t of
 
 	/* real code span */
 	if (f_begin < f_end) {
-		struct buf work = { data + f_begin, f_end - f_begin, 0, 0 };
+		struct sd_buf work = { data + f_begin, f_end - f_begin, 0, 0 };
 		if (!rndr->cb.codespan(ob, &work, rndr->opaque))
 			end = 0;
 	} else {
@@ -688,10 +688,10 @@ char_codespan(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t of
 
 /* char_escape • '\\' backslash escape */
 static size_t
-char_escape(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_escape(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	static const char *escape_chars = "\\`*_{}[]()#+-.!:|&<>^~";
-	struct buf work = { 0, 0, 0, 0 };
+	struct sd_buf work = { 0, 0, 0, 0 };
 
 	if (size > 1) {
 		if (strchr(escape_chars, data[1]) == NULL)
@@ -702,9 +702,9 @@ char_escape(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offs
 			work.size = 1;
 			rndr->cb.normal_text(ob, &work, rndr->opaque);
 		}
-		else bufputc(ob, data[1]);
+		else sd_bufputc(ob, data[1]);
 	} else if (size == 1) {
-		bufputc(ob, data[0]);
+		sd_bufputc(ob, data[0]);
 	}
 
 	return 2;
@@ -713,10 +713,10 @@ char_escape(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offs
 /* char_entity • '&' escaped when it doesn't belong to an entity */
 /* valid entities are assumed to be anything matching &#?[A-Za-z0-9]+; */
 static size_t
-char_entity(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_entity(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	size_t end = 1;
-	struct buf work = { 0, 0, 0, 0 };
+	struct sd_buf work = { 0, 0, 0, 0 };
 
 	if (end < size && data[end] == '#')
 		end++;
@@ -734,28 +734,28 @@ char_entity(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offs
 		work.size = end;
 		rndr->cb.entity(ob, &work, rndr->opaque);
 	}
-	else bufput(ob, data, end);
+	else sd_bufput(ob, data, end);
 
 	return end;
 }
 
 /* char_langle_tag • '<' when tags or autolinks are allowed */
 static size_t
-char_langle_tag(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_langle_tag(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
-	enum mkd_autolink altype = MKDA_NOT_AUTOLINK;
+	enum sd_mkd_autolink altype = MKDA_NOT_AUTOLINK;
 	size_t end = tag_length(data, size, &altype);
-	struct buf work = { data, end, 0, 0 };
+	struct sd_buf work = { data, end, 0, 0 };
 	int ret = 0;
 
 	if (end > 2) {
 		if (rndr->cb.autolink && altype != MKDA_NOT_AUTOLINK) {
-			struct buf *u_link = rndr_newbuf(rndr, BUFFER_SPAN);
+			struct sd_buf *u_link = rndr_newsd_buf(rndr, BUFFER_SPAN);
 			work.data = data + 1;
 			work.size = end - 2;
 			unscape_text(u_link, &work);
 			ret = rndr->cb.autolink(ob, u_link, altype, rndr->opaque);
-			rndr_popbuf(rndr, BUFFER_SPAN);
+			rndr_popsd_buf(rndr, BUFFER_SPAN);
 		}
 		else if (rndr->cb.raw_html_tag)
 			ret = rndr->cb.raw_html_tag(ob, &work, rndr->opaque);
@@ -766,88 +766,88 @@ char_langle_tag(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 }
 
 static size_t
-char_autolink_www(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_autolink_www(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
-	struct buf *link, *link_url, *link_text;
+	struct sd_buf *link, *link_url, *link_text;
 	size_t link_len, rewind;
 
 	if (!rndr->cb.link || rndr->in_link_body)
 		return 0;
 
-	link = rndr_newbuf(rndr, BUFFER_SPAN);
+	link = rndr_newsd_buf(rndr, BUFFER_SPAN);
 
 	if ((link_len = sd_autolink__www(&rewind, link, data, offset, size, 0)) > 0) {
-		link_url = rndr_newbuf(rndr, BUFFER_SPAN);
+		link_url = rndr_newsd_buf(rndr, BUFFER_SPAN);
 		BUFPUTSL(link_url, "http://");
-		bufput(link_url, link->data, link->size);
+		sd_bufput(link_url, link->data, link->size);
 
 		ob->size -= rewind;
 		if (rndr->cb.normal_text) {
-			link_text = rndr_newbuf(rndr, BUFFER_SPAN);
+			link_text = rndr_newsd_buf(rndr, BUFFER_SPAN);
 			rndr->cb.normal_text(link_text, link, rndr->opaque);
 			rndr->cb.link(ob, link_url, NULL, link_text, rndr->opaque);
-			rndr_popbuf(rndr, BUFFER_SPAN);
+			rndr_popsd_buf(rndr, BUFFER_SPAN);
 		} else {
 			rndr->cb.link(ob, link_url, NULL, link, rndr->opaque);
 		}
-		rndr_popbuf(rndr, BUFFER_SPAN);
+		rndr_popsd_buf(rndr, BUFFER_SPAN);
 	}
 
-	rndr_popbuf(rndr, BUFFER_SPAN);
+	rndr_popsd_buf(rndr, BUFFER_SPAN);
 	return link_len;
 }
 
 static size_t
-char_autolink_email(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_autolink_email(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
-	struct buf *link;
+	struct sd_buf *link;
 	size_t link_len, rewind;
 
 	if (!rndr->cb.autolink || rndr->in_link_body)
 		return 0;
 
-	link = rndr_newbuf(rndr, BUFFER_SPAN);
+	link = rndr_newsd_buf(rndr, BUFFER_SPAN);
 
 	if ((link_len = sd_autolink__email(&rewind, link, data, offset, size, 0)) > 0) {
 		ob->size -= rewind;
 		rndr->cb.autolink(ob, link, MKDA_EMAIL, rndr->opaque);
 	}
 
-	rndr_popbuf(rndr, BUFFER_SPAN);
+	rndr_popsd_buf(rndr, BUFFER_SPAN);
 	return link_len;
 }
 
 static size_t
-char_autolink_url(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_autolink_url(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
-	struct buf *link;
+	struct sd_buf *link;
 	size_t link_len, rewind;
 
 	if (!rndr->cb.autolink || rndr->in_link_body)
 		return 0;
 
-	link = rndr_newbuf(rndr, BUFFER_SPAN);
+	link = rndr_newsd_buf(rndr, BUFFER_SPAN);
 
 	if ((link_len = sd_autolink__url(&rewind, link, data, offset, size, 0)) > 0) {
 		ob->size -= rewind;
 		rndr->cb.autolink(ob, link, MKDA_NORMAL, rndr->opaque);
 	}
 
-	rndr_popbuf(rndr, BUFFER_SPAN);
+	rndr_popsd_buf(rndr, BUFFER_SPAN);
 	return link_len;
 }
 
 /* char_link • '[': parsing a link or an image */
 static size_t
-char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_link(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	int is_img = (offset && data[-1] == '!'), level;
 	size_t i = 1, txt_e, link_b = 0, link_e = 0, title_b = 0, title_e = 0;
-	struct buf *content = 0;
-	struct buf *link = 0;
-	struct buf *title = 0;
-	struct buf *u_link = 0;
-	size_t org_work_size = rndr->work_bufs[BUFFER_SPAN].size;
+	struct sd_buf *content = 0;
+	struct sd_buf *link = 0;
+	struct sd_buf *title = 0;
+	struct sd_buf *u_link = 0;
+	size_t org_work_size = rndr->work_sd_bufs[BUFFER_SPAN].size;
 	int text_has_nl = 0, ret = 0;
 	int in_title = 0, qtype = 0;
 
@@ -943,13 +943,13 @@ char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset
 
 		/* building escaped link and title */
 		if (link_e > link_b) {
-			link = rndr_newbuf(rndr, BUFFER_SPAN);
-			bufput(link, data + link_b, link_e - link_b);
+			link = rndr_newsd_buf(rndr, BUFFER_SPAN);
+			sd_bufput(link, data + link_b, link_e - link_b);
 		}
 
 		if (title_e > title_b) {
-			title = rndr_newbuf(rndr, BUFFER_SPAN);
-			bufput(title, data + title_b, title_e - title_b);
+			title = rndr_newsd_buf(rndr, BUFFER_SPAN);
+			sd_bufput(title, data + title_b, title_e - title_b);
 		}
 
 		i++;
@@ -957,7 +957,7 @@ char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset
 
 	/* reference style link */
 	else if (i < size && data[i] == '[') {
-		struct buf id = { 0, 0, 0, 0 };
+		struct sd_buf id = { 0, 0, 0, 0 };
 		struct link_ref *lr;
 
 		/* looking for the id */
@@ -970,14 +970,14 @@ char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset
 		/* finding the link_ref */
 		if (link_b == link_e) {
 			if (text_has_nl) {
-				struct buf *b = rndr_newbuf(rndr, BUFFER_SPAN);
+				struct sd_buf *b = rndr_newsd_buf(rndr, BUFFER_SPAN);
 				size_t j;
 
 				for (j = 1; j < txt_e; j++) {
 					if (data[j] != '\n')
-						bufputc(b, data[j]);
+						sd_bufputc(b, data[j]);
 					else if (data[j - 1] != ' ')
-						bufputc(b, ' ');
+						sd_bufputc(b, ' ');
 				}
 
 				id.data = b->data;
@@ -1003,19 +1003,19 @@ char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset
 
 	/* shortcut reference style link */
 	else {
-		struct buf id = { 0, 0, 0, 0 };
+		struct sd_buf id = { 0, 0, 0, 0 };
 		struct link_ref *lr;
 
 		/* crafting the id */
 		if (text_has_nl) {
-			struct buf *b = rndr_newbuf(rndr, BUFFER_SPAN);
+			struct sd_buf *b = rndr_newsd_buf(rndr, BUFFER_SPAN);
 			size_t j;
 
 			for (j = 1; j < txt_e; j++) {
 				if (data[j] != '\n')
-					bufputc(b, data[j]);
+					sd_bufputc(b, data[j]);
 				else if (data[j - 1] != ' ')
-					bufputc(b, ' ');
+					sd_bufputc(b, ' ');
 			}
 
 			id.data = b->data;
@@ -1040,9 +1040,9 @@ char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset
 
 	/* building content: img alt is escaped, link content is parsed */
 	if (txt_e > 1) {
-		content = rndr_newbuf(rndr, BUFFER_SPAN);
+		content = rndr_newsd_buf(rndr, BUFFER_SPAN);
 		if (is_img) {
-			bufput(content, data + 1, txt_e - 1);
+			sd_bufput(content, data + 1, txt_e - 1);
 		} else {
 			/* disable autolinking when parsing inline the
 			 * content of a link */
@@ -1053,7 +1053,7 @@ char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset
 	}
 
 	if (link) {
-		u_link = rndr_newbuf(rndr, BUFFER_SPAN);
+		u_link = rndr_newsd_buf(rndr, BUFFER_SPAN);
 		unscape_text(u_link, link);
 	}
 
@@ -1069,15 +1069,15 @@ char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset
 
 	/* cleanup */
 cleanup:
-	rndr->work_bufs[BUFFER_SPAN].size = (int)org_work_size;
+	rndr->work_sd_bufs[BUFFER_SPAN].size = (int)org_work_size;
 	return ret ? i : 0;
 }
 
 static size_t
-char_superscript(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+char_superscript(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	size_t sup_start, sup_len;
-	struct buf *sup;
+	struct sd_buf *sup;
 
 	if (!rndr->cb.superscript)
 		return 0;
@@ -1103,10 +1103,10 @@ char_superscript(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 	if (sup_len - sup_start == 0)
 		return (sup_start == 2) ? 3 : 0;
 
-	sup = rndr_newbuf(rndr, BUFFER_SPAN);
+	sup = rndr_newsd_buf(rndr, BUFFER_SPAN);
 	parse_inline(sup, rndr, data + sup_start, sup_len - sup_start);
 	rndr->cb.superscript(ob, sup, rndr->opaque);
-	rndr_popbuf(rndr, BUFFER_SPAN);
+	rndr_popsd_buf(rndr, BUFFER_SPAN);
 
 	return (sup_start == 2) ? sup_len + 1 : sup_len;
 }
@@ -1192,7 +1192,7 @@ prefix_codefence(uint8_t *data, size_t size)
 
 /* check if a line is a code fence; return its size if it is */
 static size_t
-is_codefence(uint8_t *data, size_t size, struct buf *syntax)
+is_codefence(uint8_t *data, size_t size, struct sd_buf *syntax)
 {
 	size_t i = 0, syn_len = 0;
 	uint8_t *syn_start;
@@ -1379,19 +1379,19 @@ prefix_uli(uint8_t *data, size_t size)
 
 
 /* parse_block • parsing of one block, returning next uint8_t to parse */
-static void parse_block(struct buf *ob, struct sd_markdown *rndr,
+static void parse_block(struct sd_buf *ob, struct sd_markdown *rndr,
 			uint8_t *data, size_t size);
 
 
 /* parse_blockquote • handles parsing of a blockquote fragment */
 static size_t
-parse_blockquote(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
+parse_blockquote(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t beg, end = 0, pre, work_size = 0;
 	uint8_t *work_data = 0;
-	struct buf *out = 0;
+	struct sd_buf *out = 0;
 
-	out = rndr_newbuf(rndr, BUFFER_BLOCK);
+	out = rndr_newsd_buf(rndr, BUFFER_BLOCK);
 	beg = 0;
 	while (beg < size) {
 		for (end = beg + 1; end < size && data[end - 1] != '\n'; end++);
@@ -1408,7 +1408,7 @@ parse_blockquote(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 			break;
 
 		if (beg < end) { /* copy into the in-place working buffer */
-			/* bufput(work, data + beg, end - beg); */
+			/* sd_bufput(work, data + beg, end - beg); */
 			if (!work_data)
 				work_data = data + beg;
 			else if (data + beg != work_data + work_size)
@@ -1421,20 +1421,20 @@ parse_blockquote(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 	parse_block(out, rndr, work_data, work_size);
 	if (rndr->cb.blockquote)
 		rndr->cb.blockquote(ob, out, rndr->opaque);
-	rndr_popbuf(rndr, BUFFER_BLOCK);
+	rndr_popsd_buf(rndr, BUFFER_BLOCK);
 	return end;
 }
 
 static size_t
-parse_htmlblock(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int do_render);
+parse_htmlblock(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int do_render);
 
 /* parse_blockquote • handles parsing of a regular paragraph */
 static size_t
-parse_paragraph(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
+parse_paragraph(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t i = 0, end = 0;
 	int level = 0;
-	struct buf work = { data, 0, 0, 0 };
+	struct sd_buf work = { data, 0, 0, 0 };
 
 	while (i < size) {
 		for (end = i + 1; end < size && data[end - 1] != '\n'; end++) /* empty */;
@@ -1491,13 +1491,13 @@ parse_paragraph(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 		work.size--;
 
 	if (!level) {
-		struct buf *tmp = rndr_newbuf(rndr, BUFFER_BLOCK);
+		struct sd_buf *tmp = rndr_newsd_buf(rndr, BUFFER_BLOCK);
 		parse_inline(tmp, rndr, work.data, work.size);
 		if (rndr->cb.paragraph)
 			rndr->cb.paragraph(ob, tmp, rndr->opaque);
-		rndr_popbuf(rndr, BUFFER_BLOCK);
+		rndr_popsd_buf(rndr, BUFFER_BLOCK);
 	} else {
-		struct buf *header_work;
+		struct sd_buf *header_work;
 
 		if (work.size) {
 			size_t beg;
@@ -1512,26 +1512,26 @@ parse_paragraph(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 				work.size -= 1;
 
 			if (work.size > 0) {
-				struct buf *tmp = rndr_newbuf(rndr, BUFFER_BLOCK);
+				struct sd_buf *tmp = rndr_newsd_buf(rndr, BUFFER_BLOCK);
 				parse_inline(tmp, rndr, work.data, work.size);
 
 				if (rndr->cb.paragraph)
 					rndr->cb.paragraph(ob, tmp, rndr->opaque);
 
-				rndr_popbuf(rndr, BUFFER_BLOCK);
+				rndr_popsd_buf(rndr, BUFFER_BLOCK);
 				work.data += beg;
 				work.size = i - beg;
 			}
 			else work.size = i;
 		}
 
-		header_work = rndr_newbuf(rndr, BUFFER_SPAN);
+		header_work = rndr_newsd_buf(rndr, BUFFER_SPAN);
 		parse_inline(header_work, rndr, work.data, work.size);
 
 		if (rndr->cb.header)
 			rndr->cb.header(ob, header_work, (int)level, rndr->opaque);
 
-		rndr_popbuf(rndr, BUFFER_SPAN);
+		rndr_popsd_buf(rndr, BUFFER_SPAN);
 	}
 
 	return end;
@@ -1539,20 +1539,20 @@ parse_paragraph(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 
 /* parse_fencedcode • handles parsing of a block-level code fragment */
 static size_t
-parse_fencedcode(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
+parse_fencedcode(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t beg, end;
-	struct buf *work = 0;
-	struct buf lang = { 0, 0, 0, 0 };
+	struct sd_buf *work = 0;
+	struct sd_buf lang = { 0, 0, 0, 0 };
 
 	beg = is_codefence(data, size, &lang);
 	if (beg == 0) return 0;
 
-	work = rndr_newbuf(rndr, BUFFER_BLOCK);
+	work = rndr_newsd_buf(rndr, BUFFER_BLOCK);
 
 	while (beg < size) {
 		size_t fence_end;
-		struct buf fence_trail = { 0, 0, 0, 0 };
+		struct sd_buf fence_trail = { 0, 0, 0, 0 };
 
 		fence_end = is_codefence(data + beg, size - beg, &fence_trail);
 		if (fence_end != 0 && fence_trail.size == 0) {
@@ -1566,29 +1566,29 @@ parse_fencedcode(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 			/* verbatim copy to the working buffer,
 				escaping entities */
 			if (is_empty(data + beg, end - beg))
-				bufputc(work, '\n');
-			else bufput(work, data + beg, end - beg);
+				sd_bufputc(work, '\n');
+			else sd_bufput(work, data + beg, end - beg);
 		}
 		beg = end;
 	}
 
 	if (work->size && work->data[work->size - 1] != '\n')
-		bufputc(work, '\n');
+		sd_bufputc(work, '\n');
 
 	if (rndr->cb.blockcode)
 		rndr->cb.blockcode(ob, work, lang.size ? &lang : NULL, rndr->opaque);
 
-	rndr_popbuf(rndr, BUFFER_BLOCK);
+	rndr_popsd_buf(rndr, BUFFER_BLOCK);
 	return beg;
 }
 
 static size_t
-parse_blockcode(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
+parse_blockcode(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t beg, end, pre;
-	struct buf *work = 0;
+	struct sd_buf *work = 0;
 
-	work = rndr_newbuf(rndr, BUFFER_BLOCK);
+	work = rndr_newsd_buf(rndr, BUFFER_BLOCK);
 
 	beg = 0;
 	while (beg < size) {
@@ -1605,8 +1605,8 @@ parse_blockcode(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 			/* verbatim copy to the working buffer,
 				escaping entities */
 			if (is_empty(data + beg, end - beg))
-				bufputc(work, '\n');
-			else bufput(work, data + beg, end - beg);
+				sd_bufputc(work, '\n');
+			else sd_bufput(work, data + beg, end - beg);
 		}
 		beg = end;
 	}
@@ -1614,21 +1614,21 @@ parse_blockcode(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 	while (work->size && work->data[work->size - 1] == '\n')
 		work->size -= 1;
 
-	bufputc(work, '\n');
+	sd_bufputc(work, '\n');
 
 	if (rndr->cb.blockcode)
 		rndr->cb.blockcode(ob, work, NULL, rndr->opaque);
 
-	rndr_popbuf(rndr, BUFFER_BLOCK);
+	rndr_popsd_buf(rndr, BUFFER_BLOCK);
 	return beg;
 }
 
 /* parse_listitem • parsing of a single list item */
 /*	assuming initial prefix is already removed */
 static size_t
-parse_listitem(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int *flags)
+parse_listitem(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int *flags)
 {
-	struct buf *work = 0, *inter = 0;
+	struct sd_buf *work = 0, *inter = 0;
 	size_t beg = 0, end, pre, sublist = 0, orgpre = 0, i;
 	int in_empty = 0, has_inside_empty = 0, in_fence = 0;
 
@@ -1649,11 +1649,11 @@ parse_listitem(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t s
 		end++;
 
 	/* getting working buffers */
-	work = rndr_newbuf(rndr, BUFFER_SPAN);
-	inter = rndr_newbuf(rndr, BUFFER_SPAN);
+	work = rndr_newsd_buf(rndr, BUFFER_SPAN);
+	inter = rndr_newsd_buf(rndr, BUFFER_SPAN);
 
 	/* putting the first line into the working buffer */
-	bufput(work, data + beg, end - beg);
+	sd_bufput(work, data + beg, end - beg);
 	beg = end;
 
 	/* process the following lines */
@@ -1718,14 +1718,14 @@ parse_listitem(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t s
 			break;
 		}
 		else if (in_empty) {
-			bufputc(work, '\n');
+			sd_bufputc(work, '\n');
 			has_inside_empty = 1;
 		}
 
 		in_empty = 0;
 
 		/* adding the line without prefix into the working buffer */
-		bufput(work, data + beg + i, end - beg - i);
+		sd_bufput(work, data + beg + i, end - beg - i);
 		beg = end;
 	}
 
@@ -1755,20 +1755,20 @@ parse_listitem(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t s
 	if (rndr->cb.listitem)
 		rndr->cb.listitem(ob, inter, *flags, rndr->opaque);
 
-	rndr_popbuf(rndr, BUFFER_SPAN);
-	rndr_popbuf(rndr, BUFFER_SPAN);
+	rndr_popsd_buf(rndr, BUFFER_SPAN);
+	rndr_popsd_buf(rndr, BUFFER_SPAN);
 	return beg;
 }
 
 
 /* parse_list • parsing ordered or unordered list block */
 static size_t
-parse_list(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int flags)
+parse_list(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int flags)
 {
-	struct buf *work = 0;
+	struct sd_buf *work = 0;
 	size_t i = 0, j;
 
-	work = rndr_newbuf(rndr, BUFFER_BLOCK);
+	work = rndr_newsd_buf(rndr, BUFFER_BLOCK);
 
 	while (i < size) {
 		j = parse_listitem(work, rndr, data + i, size - i, &flags);
@@ -1780,13 +1780,13 @@ parse_list(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size,
 
 	if (rndr->cb.list)
 		rndr->cb.list(ob, work, flags, rndr->opaque);
-	rndr_popbuf(rndr, BUFFER_BLOCK);
+	rndr_popsd_buf(rndr, BUFFER_BLOCK);
 	return i;
 }
 
 /* parse_atxheader • parsing of atx-style headers */
 static size_t
-parse_atxheader(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
+parse_atxheader(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t level = 0;
 	size_t i, end, skip;
@@ -1806,14 +1806,14 @@ parse_atxheader(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 		end--;
 
 	if (end > i) {
-		struct buf *work = rndr_newbuf(rndr, BUFFER_SPAN);
+		struct sd_buf *work = rndr_newsd_buf(rndr, BUFFER_SPAN);
 
 		parse_inline(work, rndr, data + i, end - i);
 
 		if (rndr->cb.header)
 			rndr->cb.header(ob, work, (int)level, rndr->opaque);
 
-		rndr_popbuf(rndr, BUFFER_SPAN);
+		rndr_popsd_buf(rndr, BUFFER_SPAN);
 	}
 
 	return skip;
@@ -1896,11 +1896,11 @@ htmlblock_end(const char *curtag,
 
 /* parse_htmlblock • parsing of inline HTML block */
 static size_t
-parse_htmlblock(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int do_render)
+parse_htmlblock(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int do_render)
 {
 	size_t i, j = 0, tag_end;
 	const char *curtag = NULL;
-	struct buf work = { data, 0, 0, 0 };
+	struct sd_buf work = { data, 0, 0, 0 };
 
 	/* identification of the opening tag */
 	if (size < 2 || data[0] != '<')
@@ -1911,7 +1911,7 @@ parse_htmlblock(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 		i++;
 
 	if (i < size)
-		curtag = find_block_tag((char *)data + 1, (int)i - 1);
+		curtag = sd_find_block_tag((char *)data + 1, (int)i - 1);
 
 	/* handling of special cases */
 	if (!curtag) {
@@ -1981,7 +1981,7 @@ parse_htmlblock(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t
 
 static void
 parse_table_row(
-	struct buf *ob,
+	struct sd_buf *ob,
 	struct sd_markdown *rndr,
 	uint8_t *data,
 	size_t size,
@@ -1990,21 +1990,21 @@ parse_table_row(
 	int header_flag)
 {
 	size_t i = 0, col;
-	struct buf *row_work = 0;
+	struct sd_buf *row_work = 0;
 
 	if (!rndr->cb.table_cell || !rndr->cb.table_row)
 		return;
 
-	row_work = rndr_newbuf(rndr, BUFFER_SPAN);
+	row_work = rndr_newsd_buf(rndr, BUFFER_SPAN);
 
 	if (i < size && data[i] == '|')
 		i++;
 
 	for (col = 0; col < columns && i < size; ++col) {
 		size_t cell_start, cell_end;
-		struct buf *cell_work;
+		struct sd_buf *cell_work;
 
-		cell_work = rndr_newbuf(rndr, BUFFER_SPAN);
+		cell_work = rndr_newsd_buf(rndr, BUFFER_SPAN);
 
 		while (i < size && _isspace(data[i]))
 			i++;
@@ -2022,23 +2022,23 @@ parse_table_row(
 		parse_inline(cell_work, rndr, data + cell_start, 1 + cell_end - cell_start);
 		rndr->cb.table_cell(row_work, cell_work, col_data[col] | header_flag, rndr->opaque);
 
-		rndr_popbuf(rndr, BUFFER_SPAN);
+		rndr_popsd_buf(rndr, BUFFER_SPAN);
 		i++;
 	}
 
 	for (; col < columns; ++col) {
-		struct buf empty_cell = { 0, 0, 0, 0 };
+		struct sd_buf empty_cell = { 0, 0, 0, 0 };
 		rndr->cb.table_cell(row_work, &empty_cell, col_data[col] | header_flag, rndr->opaque);
 	}
 
 	rndr->cb.table_row(ob, row_work, rndr->opaque);
 
-	rndr_popbuf(rndr, BUFFER_SPAN);
+	rndr_popsd_buf(rndr, BUFFER_SPAN);
 }
 
 static size_t
 parse_table_header(
-	struct buf *ob,
+	struct sd_buf *ob,
 	struct sd_markdown *rndr,
 	uint8_t *data,
 	size_t size,
@@ -2127,21 +2127,21 @@ parse_table_header(
 
 static size_t
 parse_table(
-	struct buf *ob,
+	struct sd_buf *ob,
 	struct sd_markdown *rndr,
 	uint8_t *data,
 	size_t size)
 {
 	size_t i;
 
-	struct buf *header_work = 0;
-	struct buf *body_work = 0;
+	struct sd_buf *header_work = 0;
+	struct sd_buf *body_work = 0;
 
 	size_t columns;
 	int *col_data = NULL;
 
-	header_work = rndr_newbuf(rndr, BUFFER_SPAN);
-	body_work = rndr_newbuf(rndr, BUFFER_BLOCK);
+	header_work = rndr_newsd_buf(rndr, BUFFER_SPAN);
+	body_work = rndr_newsd_buf(rndr, BUFFER_BLOCK);
 
 	i = parse_table_header(header_work, rndr, data, size, &columns, &col_data);
 	if (i > 0) {
@@ -2178,21 +2178,21 @@ parse_table(
 	}
 
 	free(col_data);
-	rndr_popbuf(rndr, BUFFER_SPAN);
-	rndr_popbuf(rndr, BUFFER_BLOCK);
+	rndr_popsd_buf(rndr, BUFFER_SPAN);
+	rndr_popsd_buf(rndr, BUFFER_BLOCK);
 	return i;
 }
 
 /* parse_block • parsing of one block, returning next uint8_t to parse */
 static void
-parse_block(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
+parse_block(struct sd_buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t beg, end, i;
 	uint8_t *txt_data;
 	beg = 0;
 
-	if (rndr->work_bufs[BUFFER_SPAN].size +
-		rndr->work_bufs[BUFFER_BLOCK].size > rndr->max_nesting)
+	if (rndr->work_sd_bufs[BUFFER_SPAN].size +
+		rndr->work_sd_bufs[BUFFER_BLOCK].size > rndr->max_nesting)
 		return;
 
 	while (beg < size) {
@@ -2352,19 +2352,19 @@ is_ref(const uint8_t *data, size_t beg, size_t end, size_t *last, struct link_re
 		if (!ref)
 			return 0;
 
-		ref->link = bufnew(link_end - link_offset);
-		bufput(ref->link, data + link_offset, link_end - link_offset);
+		ref->link = sd_bufnew(link_end - link_offset);
+		sd_bufput(ref->link, data + link_offset, link_end - link_offset);
 
 		if (title_end > title_offset) {
-			ref->title = bufnew(title_end - title_offset);
-			bufput(ref->title, data + title_offset, title_end - title_offset);
+			ref->title = sd_bufnew(title_end - title_offset);
+			sd_bufput(ref->title, data + title_offset, title_end - title_offset);
 		}
 	}
 
 	return 1;
 }
 
-static void expand_tabs(struct buf *ob, const uint8_t *line, size_t size)
+static void expand_tabs(struct sd_buf *ob, const uint8_t *line, size_t size)
 {
 	size_t  i = 0, tab = 0;
 
@@ -2376,13 +2376,13 @@ static void expand_tabs(struct buf *ob, const uint8_t *line, size_t size)
 		}
 
 		if (i > org)
-			bufput(ob, line + org, i - org);
+			sd_bufput(ob, line + org, i - org);
 
 		if (i >= size)
 			break;
 
 		do {
-			bufputc(ob, ' '); tab++;
+			sd_bufputc(ob, ' '); tab++;
 		} while (tab % 4);
 
 		i++;
@@ -2410,8 +2410,8 @@ sd_markdown_new(
 
 	memcpy(&md->cb, callbacks, sizeof(struct sd_callbacks));
 
-	stack_init(&md->work_bufs[BUFFER_BLOCK], 4);
-	stack_init(&md->work_bufs[BUFFER_SPAN], 8);
+	sd_stack_init(&md->work_sd_bufs[BUFFER_BLOCK], 4);
+	sd_stack_init(&md->work_sd_bufs[BUFFER_SPAN], 8);
 
 	memset(md->active_char, 0x0, 256);
 
@@ -2454,20 +2454,20 @@ sd_markdown_new(
 }
 
 void
-sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md)
+sd_markdown_render(struct sd_buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md)
 {
 #define MARKDOWN_GROW(x) ((x) + ((x) >> 1))
 	static const char UTF8_BOM[] = {0xEF, 0xBB, 0xBF};
 
-	struct buf *text;
+	struct sd_buf *text;
 	size_t beg, end;
 
-	text = bufnew(64);
+	text = sd_bufnew(64);
 	if (!text)
 		return;
 
 	/* Preallocate enough space for our buffer to avoid expanding while copying */
-	bufgrow(text, doc_size);
+	sd_bufgrow(text, doc_size);
 
 	/* reset the references table */
 	memset(&md->refs, 0x0, REF_TABLE_SIZE * sizeof(void *));
@@ -2495,7 +2495,7 @@ sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, str
 			while (end < doc_size && (document[end] == '\n' || document[end] == '\r')) {
 				/* add one \n per newline */
 				if (document[end] == '\n' || (end + 1 < doc_size && document[end + 1] != '\n'))
-					bufputc(text, '\n');
+					sd_bufputc(text, '\n');
 				end++;
 			}
 
@@ -2503,7 +2503,7 @@ sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, str
 		}
 
 	/* pre-grow the output buffer to minimize allocations */
-	bufgrow(ob, MARKDOWN_GROW(text->size));
+	sd_bufgrow(ob, MARKDOWN_GROW(text->size));
 
 	/* second pass: actual rendering */
 	if (md->cb.doc_header)
@@ -2512,7 +2512,7 @@ sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, str
 	if (text->size) {
 		/* adding a final newline if not already present */
 		if (text->data[text->size - 1] != '\n' &&  text->data[text->size - 1] != '\r')
-			bufputc(text, '\n');
+			sd_bufputc(text, '\n');
 
 		parse_block(ob, md, text->data, text->size);
 	}
@@ -2521,11 +2521,11 @@ sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, str
 		md->cb.doc_footer(ob, md->opaque);
 
 	/* clean-up */
-	bufrelease(text);
+	sd_bufrelease(text);
 	free_link_refs(md->refs);
 
-	assert(md->work_bufs[BUFFER_SPAN].size == 0);
-	assert(md->work_bufs[BUFFER_BLOCK].size == 0);
+	assert(md->work_sd_bufs[BUFFER_SPAN].size == 0);
+	assert(md->work_sd_bufs[BUFFER_BLOCK].size == 0);
 }
 
 void
@@ -2533,14 +2533,14 @@ sd_markdown_free(struct sd_markdown *md)
 {
 	size_t i;
 
-	for (i = 0; i < (size_t)md->work_bufs[BUFFER_SPAN].asize; ++i)
-		bufrelease(md->work_bufs[BUFFER_SPAN].item[i]);
+	for (i = 0; i < (size_t)md->work_sd_bufs[BUFFER_SPAN].asize; ++i)
+		sd_bufrelease(md->work_sd_bufs[BUFFER_SPAN].item[i]);
 
-	for (i = 0; i < (size_t)md->work_bufs[BUFFER_BLOCK].asize; ++i)
-		bufrelease(md->work_bufs[BUFFER_BLOCK].item[i]);
+	for (i = 0; i < (size_t)md->work_sd_bufs[BUFFER_BLOCK].asize; ++i)
+		sd_bufrelease(md->work_sd_bufs[BUFFER_BLOCK].item[i]);
 
-	stack_free(&md->work_bufs[BUFFER_SPAN]);
-	stack_free(&md->work_bufs[BUFFER_BLOCK]);
+	sd_stack_free(&md->work_sd_bufs[BUFFER_SPAN]);
+	sd_stack_free(&md->work_sd_bufs[BUFFER_BLOCK]);
 
 	free(md);
 }
diff --git a/src/markdown.h b/src/markdown.h
index 6f6553e..87d0dfc 100644
--- a/src/markdown.h
+++ b/src/markdown.h
@@ -36,13 +36,13 @@ extern "C" {
  ********************/
 
 /* mkd_autolink - type of autolink */
-enum mkd_autolink {
+enum sd_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 {
+enum sd_mkd_tableflags {
 	MKD_TABLE_ALIGN_L = 1,
 	MKD_TABLE_ALIGN_R = 2,
 	MKD_TABLE_ALIGN_CENTER = 3,
@@ -50,7 +50,7 @@ enum mkd_tableflags {
 	MKD_TABLE_HEADER = 4
 };
 
-enum mkd_extensions {
+enum sd_mkd_extensions {
 	MKDEXT_NO_INTRA_EMPHASIS = (1 << 0),
 	MKDEXT_TABLES = (1 << 1),
 	MKDEXT_FENCED_CODE = (1 << 2),
@@ -64,39 +64,39 @@ enum mkd_extensions {
 /* 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);
+	void (*blockcode)(struct sd_buf *ob, const struct sd_buf *text, const struct sd_buf *lang, void *opaque);
+	void (*blockquote)(struct sd_buf *ob, const struct sd_buf *text, void *opaque);
+	void (*blockhtml)(struct sd_buf *ob,const  struct sd_buf *text, void *opaque);
+	void (*header)(struct sd_buf *ob, const struct sd_buf *text, int level, void *opaque);
+	void (*hrule)(struct sd_buf *ob, void *opaque);
+	void (*list)(struct sd_buf *ob, const struct sd_buf *text, int flags, void *opaque);
+	void (*listitem)(struct sd_buf *ob, const struct sd_buf *text, int flags, void *opaque);
+	void (*paragraph)(struct sd_buf *ob, const struct sd_buf *text, void *opaque);
+	void (*table)(struct sd_buf *ob, const struct sd_buf *header, const struct sd_buf *body, void *opaque);
+	void (*table_row)(struct sd_buf *ob, const struct sd_buf *text, void *opaque);
+	void (*table_cell)(struct sd_buf *ob, const struct sd_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);
+	int (*autolink)(struct sd_buf *ob, const struct sd_buf *link, enum sd_mkd_autolink type, void *opaque);
+	int (*codespan)(struct sd_buf *ob, const struct sd_buf *text, void *opaque);
+	int (*double_emphasis)(struct sd_buf *ob, const struct sd_buf *text, void *opaque);
+	int (*emphasis)(struct sd_buf *ob, const struct sd_buf *text, void *opaque);
+	int (*image)(struct sd_buf *ob, const struct sd_buf *link, const struct sd_buf *title, const struct sd_buf *alt, void *opaque);
+	int (*linebreak)(struct sd_buf *ob, void *opaque);
+	int (*link)(struct sd_buf *ob, const struct sd_buf *link, const struct sd_buf *title, const struct sd_buf *content, void *opaque);
+	int (*raw_html_tag)(struct sd_buf *ob, const struct sd_buf *tag, void *opaque);
+	int (*triple_emphasis)(struct sd_buf *ob, const struct sd_buf *text, void *opaque);
+	int (*strikethrough)(struct sd_buf *ob, const struct sd_buf *text, void *opaque);
+	int (*superscript)(struct sd_buf *ob, const struct sd_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);
+	void (*entity)(struct sd_buf *ob, const struct sd_buf *entity, void *opaque);
+	void (*normal_text)(struct sd_buf *ob, const struct sd_buf *text, void *opaque);
 
 	/* header and footer */
-	void (*doc_header)(struct buf *ob, void *opaque);
-	void (*doc_footer)(struct buf *ob, void *opaque);
+	void (*doc_header)(struct sd_buf *ob, void *opaque);
+	void (*doc_footer)(struct sd_buf *ob, void *opaque);
 };
 
 struct sd_markdown;
@@ -121,7 +121,7 @@ sd_markdown_new(
 	void *opaque);
 
 extern void
-sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md);
+sd_markdown_render(struct sd_buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md);
 
 extern void
 sd_markdown_free(struct sd_markdown *md);
diff --git a/src/stack.c b/src/stack.c
index ce069ff..442d440 100644
--- a/src/stack.c
+++ b/src/stack.c
@@ -2,7 +2,7 @@
 #include <string.h>
 
 int
-stack_grow(struct stack *st, size_t new_size)
+sd_stack_grow(struct sd_stack *st, size_t new_size)
 {
 	void **new_st;
 
@@ -26,7 +26,7 @@ stack_grow(struct stack *st, size_t new_size)
 }
 
 void
-stack_free(struct stack *st)
+sd_stack_free(struct sd_stack *st)
 {
 	if (!st)
 		return;
@@ -39,7 +39,7 @@ stack_free(struct stack *st)
 }
 
 int
-stack_init(struct stack *st, size_t initial_size)
+sd_stack_init(struct sd_stack *st, size_t initial_size)
 {
 	st->item = NULL;
 	st->size = 0;
@@ -48,11 +48,11 @@ stack_init(struct stack *st, size_t initial_size)
 	if (!initial_size)
 		initial_size = 8;
 
-	return stack_grow(st, initial_size);
+	return sd_stack_grow(st, initial_size);
 }
 
 void *
-stack_pop(struct stack *st)
+sd_stack_pop(struct sd_stack *st)
 {
 	if (!st->size)
 		return NULL;
@@ -61,9 +61,9 @@ stack_pop(struct stack *st)
 }
 
 int
-stack_push(struct stack *st, void *item)
+sd_stack_push(struct sd_stack *st, void *item)
 {
-	if (stack_grow(st, st->size * 2) < 0)
+	if (sd_stack_grow(st, st->size * 2) < 0)
 		return -1;
 
 	st->item[st->size++] = item;
@@ -71,7 +71,7 @@ stack_push(struct stack *st, void *item)
 }
 
 void *
-stack_top(struct stack *st)
+sd_stack_top(struct sd_stack *st)
 {
 	if (!st->size)
 		return NULL;
diff --git a/src/stack.h b/src/stack.h
index 08ff030..4e66d22 100644
--- a/src/stack.h
+++ b/src/stack.h
@@ -7,20 +7,20 @@
 extern "C" {
 #endif
 
-struct stack {
+struct sd_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);
+void sd_stack_free(struct sd_stack *);
+int sd_stack_grow(struct sd_stack *, size_t);
+int sd_stack_init(struct sd_stack *, size_t);
 
-int stack_push(struct stack *, void *);
+int sd_stack_push(struct sd_stack *, void *);
 
-void *stack_pop(struct stack *);
-void *stack_top(struct stack *);
+void *sd_stack_pop(struct sd_stack *);
+void *sd_stack_top(struct sd_stack *);
 
 #ifdef __cplusplus
 }