cmark

diff --git a/src/buffer.c b/src/buffer.c
@@ -12,8 +12,8 @@
 /* Used as default value for strbuf->ptr so that people can always
  * assume ptr is non-NULL and zero terminated even for new strbufs.
  */
-unsigned char strbuf__initbuf[1];
-unsigned char strbuf__oom[1];
+unsigned char cmark_strbuf__initbuf[1];
+unsigned char cmark_strbuf__oom[1];
 
 #define ENSURE_SIZE(b, d)					\
 	if ((d) > buf->asize && strbuf_grow(b, (d)) < 0)	\
@@ -23,22 +23,22 @@ unsigned char strbuf__oom[1];
 #define MIN(x,y)  ((x<y) ? x : y)
 #endif
 
-void strbuf_init(strbuf *buf, int initial_size)
+void cmark_strbuf_init(strbuf *buf, int initial_size)
 {
 	buf->asize = 0;
 	buf->size = 0;
-	buf->ptr = strbuf__initbuf;
+	buf->ptr = cmark_strbuf__initbuf;
 
 	if (initial_size)
-		strbuf_grow(buf, initial_size);
+		cmark_strbuf_grow(buf, initial_size);
 }
 
-int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom)
+int cmark_strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom)
 {
 	unsigned char *new_ptr;
 	int new_size;
 
-	if (buf->ptr == strbuf__oom)
+	if (buf->ptr == cmark_strbuf__oom)
 		return -1;
 
 	if (target_size <= buf->asize)
@@ -64,7 +64,7 @@ int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom)
 
 	if (!new_ptr) {
 		if (mark_oom)
-			buf->ptr = strbuf__oom;
+			buf->ptr = cmark_strbuf__oom;
 		return -1;
 	}
 
@@ -79,17 +79,17 @@ int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom)
 	return 0;
 }
 
-void strbuf_free(strbuf *buf)
+void cmark_strbuf_free(strbuf *buf)
 {
 	if (!buf) return;
 
-	if (buf->ptr != strbuf__initbuf && buf->ptr != strbuf__oom)
+	if (buf->ptr != cmark_strbuf__initbuf && buf->ptr != cmark_strbuf__oom)
 		free(buf->ptr);
 
-	strbuf_init(buf, 0);
+	cmark_strbuf_init(buf, 0);
 }
 
-void strbuf_clear(strbuf *buf)
+void cmark_strbuf_clear(strbuf *buf)
 {
 	buf->size = 0;
 
@@ -97,10 +97,10 @@ void strbuf_clear(strbuf *buf)
 		buf->ptr[0] = '\0';
 }
 
-int strbuf_set(strbuf *buf, const unsigned char *data, int len)
+int cmark_strbuf_set(strbuf *buf, const unsigned char *data, int len)
 {
 	if (len <= 0 || data == NULL) {
-		strbuf_clear(buf);
+		cmark_strbuf_clear(buf);
 	} else {
 		if (data != buf->ptr) {
 			ENSURE_SIZE(buf, len + 1);
@@ -112,14 +112,14 @@ int strbuf_set(strbuf *buf, const unsigned char *data, int len)
 	return 0;
 }
 
-int strbuf_sets(strbuf *buf, const char *string)
+int cmark_strbuf_sets(strbuf *buf, const char *string)
 {
-	return strbuf_set(buf,
+	return cmark_strbuf_set(buf,
 			  (const unsigned char *)string,
 			  string ? strlen(string) : 0);
 }
 
-int strbuf_putc(strbuf *buf, int c)
+int cmark_strbuf_putc(strbuf *buf, int c)
 {
 	ENSURE_SIZE(buf, buf->size + 2);
 	buf->ptr[buf->size++] = c;
@@ -127,7 +127,7 @@ int strbuf_putc(strbuf *buf, int c)
 	return 0;
 }
 
-int strbuf_put(strbuf *buf, const unsigned char *data, int len)
+int cmark_strbuf_put(strbuf *buf, const unsigned char *data, int len)
 {
 	if (len <= 0)
 		return 0;
@@ -139,12 +139,12 @@ int strbuf_put(strbuf *buf, const unsigned char *data, int len)
 	return 0;
 }
 
-int strbuf_puts(strbuf *buf, const char *string)
+int cmark_strbuf_puts(strbuf *buf, const char *string)
 {
-	return strbuf_put(buf, (const unsigned char *)string, strlen(string));
+	return cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string));
 }
 
-int strbuf_vprintf(strbuf *buf, const char *format, va_list ap)
+int cmark_strbuf_vprintf(strbuf *buf, const char *format, va_list ap)
 {
 	const int expected_size = buf->size + (strlen(format) * 2);
 	int len;
@@ -163,7 +163,7 @@ int strbuf_vprintf(strbuf *buf, const char *format, va_list ap)
 
 		if (len < 0) {
 			free(buf->ptr);
-			buf->ptr = strbuf__oom;
+			buf->ptr = cmark_strbuf__oom;
 			return -1;
 		}
 
@@ -178,19 +178,19 @@ int strbuf_vprintf(strbuf *buf, const char *format, va_list ap)
 	return 0;
 }
 
-int strbuf_printf(strbuf *buf, const char *format, ...)
+int cmark_strbuf_printf(strbuf *buf, const char *format, ...)
 {
 	int r;
 	va_list ap;
 
 	va_start(ap, format);
-	r = strbuf_vprintf(buf, format, ap);
+	r = cmark_strbuf_vprintf(buf, format, ap);
 	va_end(ap);
 
 	return r;
 }
 
-void strbuf_copy_cstr(char *data, int datasize, const strbuf *buf)
+void cmark_strbuf_copy_cstr(char *data, int datasize, const strbuf *buf)
 {
 	int copylen;
 
@@ -208,29 +208,29 @@ void strbuf_copy_cstr(char *data, int datasize, const strbuf *buf)
 	data[copylen] = '\0';
 }
 
-void strbuf_swap(strbuf *buf_a, strbuf *buf_b)
+void cmark_strbuf_swap(strbuf *buf_a, strbuf *buf_b)
 {
 	strbuf t = *buf_a;
 	*buf_a = *buf_b;
 	*buf_b = t;
 }
 
-unsigned char *strbuf_detach(strbuf *buf)
+unsigned char *cmark_strbuf_detach(strbuf *buf)
 {
 	unsigned char *data = buf->ptr;
 
-	if (buf->asize == 0 || buf->ptr == strbuf__oom) {
+	if (buf->asize == 0 || buf->ptr == cmark_strbuf__oom) {
 		/* return an empty string */
 		return calloc(1, 1);
 	}
 
-	strbuf_init(buf, 0);
+	cmark_strbuf_init(buf, 0);
 	return data;
 }
 
-void strbuf_attach(strbuf *buf, unsigned char *ptr, int asize)
+void cmark_strbuf_attach(strbuf *buf, unsigned char *ptr, int asize)
 {
-	strbuf_free(buf);
+	cmark_strbuf_free(buf);
 
 	if (ptr) {
 		buf->ptr = ptr;
@@ -240,18 +240,18 @@ void strbuf_attach(strbuf *buf, unsigned char *ptr, int asize)
 		else /* pass 0 to fall back on strlen + 1 */
 			buf->asize = buf->size + 1;
 	} else {
-		strbuf_grow(buf, asize);
+		cmark_strbuf_grow(buf, asize);
 	}
 }
 
-int strbuf_cmp(const strbuf *a, const strbuf *b)
+int cmark_strbuf_cmp(const strbuf *a, const strbuf *b)
 {
 	int result = memcmp(a->ptr, b->ptr, MIN(a->size, b->size));
 	return (result != 0) ? result :
 		(a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0;
 }
 
-int strbuf_strchr(const strbuf *buf, int c, int pos)
+int cmark_strbuf_strchr(const strbuf *buf, int c, int pos)
 {
 	const unsigned char *p = memchr(buf->ptr + pos, c, buf->size - pos);
 	if (!p)
@@ -260,7 +260,7 @@ int strbuf_strchr(const strbuf *buf, int c, int pos)
 	return (int)(p - (const unsigned char *)buf->ptr);
 }
 
-int strbuf_strrchr(const strbuf *buf, int c, int pos)
+int cmark_strbuf_strrchr(const strbuf *buf, int c, int pos)
 {
 	int i;
 
@@ -272,7 +272,7 @@ int strbuf_strrchr(const strbuf *buf, int c, int pos)
 	return -1;
 }
 
-void strbuf_truncate(strbuf *buf, int len)
+void cmark_strbuf_truncate(strbuf *buf, int len)
 {
 	if (len < buf->size) {
 		buf->size = len;
@@ -280,7 +280,7 @@ void strbuf_truncate(strbuf *buf, int len)
 	}
 }
 
-void strbuf_drop(strbuf *buf, int n)
+void cmark_strbuf_drop(strbuf *buf, int n)
 {
 	if (n > 0) {
 		buf->size = buf->size - n;
@@ -291,7 +291,7 @@ void strbuf_drop(strbuf *buf, int n)
 	}
 }
 
-void strbuf_rtrim(strbuf *buf)
+void cmark_strbuf_rtrim(strbuf *buf)
 {
 	if (!buf->size)
 		return;
@@ -306,7 +306,7 @@ void strbuf_rtrim(strbuf *buf)
 	buf->ptr[buf->size] = '\0';
 }
 
-void strbuf_trim(strbuf *buf)
+void cmark_strbuf_trim(strbuf *buf)
 {
 	int i = 0;
 
@@ -316,14 +316,14 @@ void strbuf_trim(strbuf *buf)
 	while (i < buf->size && isspace(buf->ptr[i]))
 		i++;
 
-	strbuf_drop(buf, i);
+	cmark_strbuf_drop(buf, i);
 
-	strbuf_rtrim(buf);
+	cmark_strbuf_rtrim(buf);
 }
 
 // Destructively modify string, collapsing consecutive
 // space and newline characters into a single space.
-void strbuf_normalize_whitespace(strbuf *s)
+void cmark_strbuf_normalize_whitespace(strbuf *s)
 {
 	bool last_char_was_space = false;
 	int r, w;
@@ -345,11 +345,11 @@ void strbuf_normalize_whitespace(strbuf *s)
 		}
 	}
 
-	strbuf_truncate(s, w);
+	cmark_strbuf_truncate(s, w);
 }
 
 // Destructively unescape a string: remove backslashes before punctuation chars.
-extern void strbuf_unescape(strbuf *buf)
+extern void cmark_strbuf_unescape(strbuf *buf)
 {
 	int r, w;
 
@@ -360,5 +360,5 @@ extern void strbuf_unescape(strbuf *buf)
 		buf->ptr[w++] = buf->ptr[r];
 	}
 
-	strbuf_truncate(buf, w);
+	cmark_strbuf_truncate(buf, w);
 }