Re-added cmark_ prefix to strbuf and chunk.

Reverts 225d720.

1 files changed, 54 insertions, 54 deletions

diff --git a/src/buffer.c b/src/buffer.c
index 765cb46..73a9728 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -8,36 +8,36 @@
 
 #include "buffer.h"
 
-/* Used as default value for strbuf->ptr so that people can always
- * assume ptr is non-NULL and zero terminated even for new strbufs.
+/* Used as default value for cmark_strbuf->ptr so that people can always
+ * assume ptr is non-NULL and zero terminated even for new cmark_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)	\
+	if ((d) > buf->asize && cmark_strbuf_grow(b, (d)) < 0)	\
 		return -1;
 
 #ifndef MIN
 #define MIN(x,y)  ((x<y) ? x : y)
 #endif
 
-void strbuf_init(strbuf *buf, int initial_size)
+void cmark_strbuf_init(cmark_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(cmark_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)
@@ -63,7 +63,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;
 	}
 
@@ -78,32 +78,32 @@ int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom)
 	return 0;
 }
 
-int strbuf_grow(strbuf *buf, int target_size)
+int cmark_strbuf_grow(cmark_strbuf *buf, int target_size)
 {
-	return strbuf_try_grow(buf, target_size, true);
+	return cmark_strbuf_try_grow(buf, target_size, true);
 }
 
-bool strbuf_oom(const strbuf *buf)
+bool cmark_strbuf_oom(const cmark_strbuf *buf)
 {
-	return (buf->ptr == strbuf__oom);
+	return (buf->ptr == cmark_strbuf__oom);
 }
 
-size_t strbuf_len(const strbuf *buf)
+size_t cmark_strbuf_len(const cmark_strbuf *buf)
 {
 	return buf->size;
 }
 
-void strbuf_free(strbuf *buf)
+void cmark_strbuf_free(cmark_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(cmark_strbuf *buf)
 {
 	buf->size = 0;
 
@@ -111,10 +111,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(cmark_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);
@@ -126,14 +126,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(cmark_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(cmark_strbuf *buf, int c)
 {
 	ENSURE_SIZE(buf, buf->size + 2);
 	buf->ptr[buf->size++] = c;
@@ -141,7 +141,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(cmark_strbuf *buf, const unsigned char *data, int len)
 {
 	if (len <= 0)
 		return 0;
@@ -153,12 +153,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(cmark_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(cmark_strbuf *buf, const char *format, va_list ap)
 {
 	const int expected_size = buf->size + (strlen(format) * 2);
 	int len;
@@ -174,7 +174,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;
 		}
 
@@ -189,19 +189,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(cmark_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 cmark_strbuf *buf)
 {
 	int copylen;
 
@@ -219,29 +219,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(cmark_strbuf *buf_a, cmark_strbuf *buf_b)
 {
-	strbuf t = *buf_a;
+	cmark_strbuf t = *buf_a;
 	*buf_a = *buf_b;
 	*buf_b = t;
 }
 
-unsigned char *strbuf_detach(strbuf *buf)
+unsigned char *cmark_strbuf_detach(cmark_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 (unsigned char *)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(cmark_strbuf *buf, unsigned char *ptr, int asize)
 {
-	strbuf_free(buf);
+	cmark_strbuf_free(buf);
 
 	if (ptr) {
 		buf->ptr = ptr;
@@ -251,18 +251,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 cmark_strbuf *a, const cmark_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 cmark_strbuf *buf, int c, int pos)
 {
 	const unsigned char *p = (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos);
 	if (!p)
@@ -271,7 +271,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 cmark_strbuf *buf, int c, int pos)
 {
 	int i;
 
@@ -283,7 +283,7 @@ int strbuf_strrchr(const strbuf *buf, int c, int pos)
 	return -1;
 }
 
-void strbuf_truncate(strbuf *buf, int len)
+void cmark_strbuf_truncate(cmark_strbuf *buf, int len)
 {
 	if (len < buf->size) {
 		buf->size = len;
@@ -291,7 +291,7 @@ void strbuf_truncate(strbuf *buf, int len)
 	}
 }
 
-void strbuf_drop(strbuf *buf, int n)
+void cmark_strbuf_drop(cmark_strbuf *buf, int n)
 {
 	if (n > 0) {
 		buf->size = buf->size - n;
@@ -302,7 +302,7 @@ void strbuf_drop(strbuf *buf, int n)
 	}
 }
 
-void strbuf_rtrim(strbuf *buf)
+void cmark_strbuf_rtrim(cmark_strbuf *buf)
 {
 	if (!buf->size)
 		return;
@@ -317,7 +317,7 @@ void strbuf_rtrim(strbuf *buf)
 	buf->ptr[buf->size] = '\0';
 }
 
-void strbuf_trim(strbuf *buf)
+void cmark_strbuf_trim(cmark_strbuf *buf)
 {
 	int i = 0;
 
@@ -327,14 +327,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(cmark_strbuf *s)
 {
 	bool last_char_was_space = false;
 	int r, w;
@@ -356,11 +356,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(cmark_strbuf *buf)
 {
 	int r, w;
 
@@ -371,5 +371,5 @@ extern void strbuf_unescape(strbuf *buf)
 		buf->ptr[w++] = buf->ptr[r];
 	}
 
-	strbuf_truncate(buf, w);
+	cmark_strbuf_truncate(buf, w);
 }