rugged 1.1.1 → 1.4.3

data/vendor/libgit2/src/{buffer.c → str.c}

@@ -4,43 +4,42 @@
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */
-#include "buffer.h"
+
+#include "str.h"
 #include "posix.h"
-#include "git2/buffer.h"
-#include "buf_text.h"
 #include <ctype.h>
 
-/* Used as default value for git_buf->ptr so that people can always
- * assume ptr is non-NULL and zero terminated even for new git_bufs.
+/* Used as default value for git_str->ptr so that people can always
+ * assume ptr is non-NULL and zero terminated even for new git_strs.
  */
-char git_buf__initbuf[1];
+char git_str__initstr[1];
 
-char git_buf__oom[1];
+char git_str__oom[1];
 
 #define ENSURE_SIZE(b, d) \
-	if ((b)->ptr == git_buf__oom || \
-	    ((d) > (b)->asize && git_buf_grow((b), (d)) < 0))\
+	if ((b)->ptr == git_str__oom || \
+	    ((d) > (b)->asize && git_str_grow((b), (d)) < 0))\
 		return -1;
 
 
-int git_buf_init(git_buf *buf, size_t initial_size)
+int git_str_init(git_str *buf, size_t initial_size)
 {
 	buf->asize = 0;
 	buf->size = 0;
-	buf->ptr = git_buf__initbuf;
+	buf->ptr = git_str__initstr;
 
 	ENSURE_SIZE(buf, initial_size);
 
 	return 0;
 }
 
-int git_buf_try_grow(
-	git_buf *buf, size_t target_size, bool mark_oom)
+int git_str_try_grow(
+	git_str *buf, size_t target_size, bool mark_oom)
 {
 	char *new_ptr;
 	size_t new_size;
 
-	if (buf->ptr == git_buf__oom)
+	if (buf->ptr == git_str__oom)
 		return -1;
 
 	if (buf->asize == 0 && buf->size != 0) {
@@ -75,9 +74,9 @@ int git_buf_try_grow(
 
 	if (new_size < buf->size) {
 		if (mark_oom) {
-			if (buf->ptr && buf->ptr != git_buf__initbuf)
+			if (buf->ptr && buf->ptr != git_str__initstr)
 				git__free(buf->ptr);
-			buf->ptr = git_buf__oom;
+			buf->ptr = git_str__oom;
 		}
 
 		git_error_set_oom();
@@ -88,9 +87,9 @@ int git_buf_try_grow(
 
 	if (!new_ptr) {
 		if (mark_oom) {
-			if (buf->ptr && (buf->ptr != git_buf__initbuf))
+			if (buf->ptr && (buf->ptr != git_str__initstr))
 				git__free(buf->ptr);
-			buf->ptr = git_buf__oom;
+			buf->ptr = git_str__oom;
 		}
 		return -1;
 	}
@@ -106,55 +105,39 @@ int git_buf_try_grow(
 	return 0;
 }
 
-int git_buf_grow(git_buf *buffer, size_t target_size)
+int git_str_grow(git_str *buffer, size_t target_size)
 {
-	return git_buf_try_grow(buffer, target_size, true);
+	return git_str_try_grow(buffer, target_size, true);
 }
 
-int git_buf_grow_by(git_buf *buffer, size_t additional_size)
+int git_str_grow_by(git_str *buffer, size_t additional_size)
 {
 	size_t newsize;
 
 	if (GIT_ADD_SIZET_OVERFLOW(&newsize, buffer->size, additional_size)) {
-		buffer->ptr = git_buf__oom;
+		buffer->ptr = git_str__oom;
 		return -1;
 	}
 
-	return git_buf_try_grow(buffer, newsize, true);
+	return git_str_try_grow(buffer, newsize, true);
 }
 
-void git_buf_dispose(git_buf *buf)
+void git_str_dispose(git_str *buf)
 {
 	if (!buf) return;
 
-	if (buf->asize > 0 && buf->ptr != NULL && buf->ptr != git_buf__oom)
+	if (buf->asize > 0 && buf->ptr != NULL && buf->ptr != git_str__oom)
 		git__free(buf->ptr);
 
-	git_buf_init(buf, 0);
-}
-
-#ifndef GIT_DEPRECATE_HARD
-void git_buf_free(git_buf *buf)
-{
-	git_buf_dispose(buf);
-}
-#endif
-
-void git_buf_sanitize(git_buf *buf)
-{
-	if (buf->ptr == NULL) {
-		assert(buf->size == 0 && buf->asize == 0);
-		buf->ptr = git_buf__initbuf;
-	} else if (buf->asize > buf->size)
-		buf->ptr[buf->size] = '\0';
+	git_str_init(buf, 0);
 }
 
-void git_buf_clear(git_buf *buf)
+void git_str_clear(git_str *buf)
 {
 	buf->size = 0;
 
 	if (!buf->ptr) {
-		buf->ptr = git_buf__initbuf;
+		buf->ptr = git_str__initstr;
 		buf->asize = 0;
 	}
 
@@ -162,12 +145,12 @@ void git_buf_clear(git_buf *buf)
 		buf->ptr[0] = '\0';
 }
 
-int git_buf_set(git_buf *buf, const void *data, size_t len)
+int git_str_set(git_str *buf, const void *data, size_t len)
 {
 	size_t alloclen;
 
 	if (len == 0 || data == NULL) {
-		git_buf_clear(buf);
+		git_str_clear(buf);
 	} else {
 		if (data != buf->ptr) {
 			GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, len, 1);
@@ -183,22 +166,12 @@ int git_buf_set(git_buf *buf, const void *data, size_t len)
 	return 0;
 }
 
-int git_buf_is_binary(const git_buf *buf)
+int git_str_sets(git_str *buf, const char *string)
 {
-	return git_buf_text_is_binary(buf);
+	return git_str_set(buf, string, string ? strlen(string) : 0);
 }
 
-int git_buf_contains_nul(const git_buf *buf)
-{
-	return git_buf_text_contains_nul(buf);
-}
-
-int git_buf_sets(git_buf *buf, const char *string)
-{
-	return git_buf_set(buf, string, string ? strlen(string) : 0);
-}
-
-int git_buf_putc(git_buf *buf, char c)
+int git_str_putc(git_str *buf, char c)
 {
 	size_t new_size;
 	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, 2);
@@ -208,7 +181,7 @@ int git_buf_putc(git_buf *buf, char c)
 	return 0;
 }
 
-int git_buf_putcn(git_buf *buf, char c, size_t len)
+int git_str_putcn(git_str *buf, char c, size_t len)
 {
 	size_t new_size;
 	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
@@ -220,12 +193,12 @@ int git_buf_putcn(git_buf *buf, char c, size_t len)
 	return 0;
 }
 
-int git_buf_put(git_buf *buf, const char *data, size_t len)
+int git_str_put(git_str *buf, const char *data, size_t len)
 {
 	if (len) {
 		size_t new_size;
 
-		assert(data);
+		GIT_ASSERT_ARG(data);
 
 		GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
 		GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
@@ -237,16 +210,43 @@ int git_buf_put(git_buf *buf, const char *data, size_t len)
 	return 0;
 }
 
-int git_buf_puts(git_buf *buf, const char *string)
+int git_str_puts(git_str *buf, const char *string)
+{
+	GIT_ASSERT_ARG(string);
+
+	return git_str_put(buf, string, strlen(string));
+}
+
+static char hex_encode[] = "0123456789abcdef";
+
+int git_str_encode_hexstr(git_str *str, const char *data, size_t len)
 {
-	assert(string);
-	return git_buf_put(buf, string, strlen(string));
+	size_t new_size, i;
+	char *s;
+
+	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&new_size, len, 2);
+	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
+
+	if (git_str_grow_by(str, new_size) < 0)
+		return -1;
+
+	s = str->ptr + str->size;
+
+	for (i = 0; i < len; i++) {
+		*s++ = hex_encode[(data[i] & 0xf0) >> 4];
+		*s++ = hex_encode[(data[i] & 0x0f)];
+	}
+
+	str->size += (len * 2);
+	str->ptr[str->size] = '\0';
+
+	return 0;
 }
 
 static const char base64_encode[] =
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-int git_buf_encode_base64(git_buf *buf, const char *data, size_t len)
+int git_str_encode_base64(git_str *buf, const char *data, size_t len)
 {
 	size_t extra = len % 3;
 	uint8_t *write, a, b, c;
@@ -308,7 +308,7 @@ static const int8_t base64_decode[] = {
 	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 };
 
-int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len)
+int git_str_decode_base64(git_str *buf, const char *base64, size_t len)
 {
 	size_t i;
 	int8_t a, b, c, d;
@@ -319,7 +319,7 @@ int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len)
 		return -1;
 	}
 
-	assert(len % 4 == 0);
+	GIT_ASSERT_ARG(len % 4 == 0);
 	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, (len / 4 * 3), buf->size);
 	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
 	ENSURE_SIZE(buf, new_size);
@@ -348,7 +348,7 @@ int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len)
 static const char base85_encode[] =
 	"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";
 
-int git_buf_encode_base85(git_buf *buf, const char *data, size_t len)
+int git_str_encode_base85(git_str *buf, const char *data, size_t len)
 {
 	size_t blocks = (len / 4) + !!(len % 4), alloclen;
 
@@ -407,8 +407,8 @@ static const int8_t base85_decode[] = {
 	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 };
 
-int git_buf_decode_base85(
-	git_buf *buf,
+int git_str_decode_base85(
+	git_str *buf,
 	const char *base85,
 	size_t base85_len,
 	size_t output_len)
@@ -471,8 +471,8 @@ on_error:
 
 #define HEX_DECODE(c) ((c | 32) % 39 - 9)
 
-int git_buf_decode_percent(
-	git_buf *buf,
+int git_str_decode_percent(
+	git_str *buf,
 	const char *str,
 	size_t str_len)
 {
@@ -499,7 +499,7 @@ int git_buf_decode_percent(
 	return 0;
 }
 
-int git_buf_vprintf(git_buf *buf, const char *format, va_list ap)
+int git_str_vprintf(git_str *buf, const char *format, va_list ap)
 {
 	size_t expected_size, new_size;
 	int len;
@@ -522,7 +522,7 @@ int git_buf_vprintf(git_buf *buf, const char *format, va_list ap)
 
 		if (len < 0) {
 			git__free(buf->ptr);
-			buf->ptr = git_buf__oom;
+			buf->ptr = git_str__oom;
 			return -1;
 		}
 
@@ -539,42 +539,46 @@ int git_buf_vprintf(git_buf *buf, const char *format, va_list ap)
 	return 0;
 }
 
-int git_buf_printf(git_buf *buf, const char *format, ...)
+int git_str_printf(git_str *buf, const char *format, ...)
 {
 	int r;
 	va_list ap;
 
 	va_start(ap, format);
-	r = git_buf_vprintf(buf, format, ap);
+	r = git_str_vprintf(buf, format, ap);
 	va_end(ap);
 
 	return r;
 }
 
-void git_buf_copy_cstr(char *data, size_t datasize, const git_buf *buf)
+int git_str_copy_cstr(char *data, size_t datasize, const git_str *buf)
 {
 	size_t copylen;
 
-	assert(data && datasize && buf);
+	GIT_ASSERT_ARG(data);
+	GIT_ASSERT_ARG(datasize);
+	GIT_ASSERT_ARG(buf);
 
 	data[0] = '\0';
 
 	if (buf->size == 0 || buf->asize <= 0)
-		return;
+		return 0;
 
 	copylen = buf->size;
 	if (copylen > datasize - 1)
 		copylen = datasize - 1;
 	memmove(data, buf->ptr, copylen);
 	data[copylen] = '\0';
+
+	return 0;
 }
 
-void git_buf_consume_bytes(git_buf *buf, size_t len)
+void git_str_consume_bytes(git_str *buf, size_t len)
 {
-	git_buf_consume(buf, buf->ptr + len);
+	git_str_consume(buf, buf->ptr + len);
 }
 
-void git_buf_consume(git_buf *buf, const char *end)
+void git_str_consume(git_str *buf, const char *end)
 {
 	if (end > buf->ptr && end <= buf->ptr + buf->size) {
 		size_t consumed = end - buf->ptr;
@@ -584,7 +588,7 @@ void git_buf_consume(git_buf *buf, const char *end)
 	}
 }
 
-void git_buf_truncate(git_buf *buf, size_t len)
+void git_str_truncate(git_str *buf, size_t len)
 {
 	if (len >= buf->size)
 		return;
@@ -594,42 +598,49 @@ void git_buf_truncate(git_buf *buf, size_t len)
 		buf->ptr[buf->size] = '\0';
 }
 
-void git_buf_shorten(git_buf *buf, size_t amount)
+void git_str_shorten(git_str *buf, size_t amount)
 {
 	if (buf->size > amount)
-		git_buf_truncate(buf, buf->size - amount);
+		git_str_truncate(buf, buf->size - amount);
 	else
-		git_buf_clear(buf);
+		git_str_clear(buf);
 }
 
-void git_buf_rtruncate_at_char(git_buf *buf, char separator)
+void git_str_truncate_at_char(git_str *buf, char separator)
 {
-	ssize_t idx = git_buf_rfind_next(buf, separator);
-	git_buf_truncate(buf, idx < 0 ? 0 : (size_t)idx);
+	ssize_t idx = git_str_find(buf, separator);
+	if (idx >= 0)
+		git_str_truncate(buf, (size_t)idx);
 }
 
-void git_buf_swap(git_buf *buf_a, git_buf *buf_b)
+void git_str_rtruncate_at_char(git_str *buf, char separator)
 {
-	git_buf t = *buf_a;
-	*buf_a = *buf_b;
-	*buf_b = t;
+	ssize_t idx = git_str_rfind_next(buf, separator);
+	git_str_truncate(buf, idx < 0 ? 0 : (size_t)idx);
 }
 
-char *git_buf_detach(git_buf *buf)
+void git_str_swap(git_str *str_a, git_str *str_b)
+{
+	git_str t = *str_a;
+	*str_a = *str_b;
+	*str_b = t;
+}
+
+char *git_str_detach(git_str *buf)
 {
 	char *data = buf->ptr;
 
-	if (buf->asize == 0 || buf->ptr == git_buf__oom)
+	if (buf->asize == 0 || buf->ptr == git_str__oom)
 		return NULL;
 
-	git_buf_init(buf, 0);
+	git_str_init(buf, 0);
 
 	return data;
 }
 
-int git_buf_attach(git_buf *buf, char *ptr, size_t asize)
+int git_str_attach(git_str *buf, char *ptr, size_t asize)
 {
-	git_buf_dispose(buf);
+	git_str_dispose(buf);
 
 	if (ptr) {
 		buf->ptr = ptr;
@@ -644,13 +655,13 @@ int git_buf_attach(git_buf *buf, char *ptr, size_t asize)
 	return 0;
 }
 
-void git_buf_attach_notowned(git_buf *buf, const char *ptr, size_t size)
+void git_str_attach_notowned(git_str *buf, const char *ptr, size_t size)
 {
-	if (git_buf_is_allocated(buf))
-		git_buf_dispose(buf);
+	if (git_str_is_allocated(buf))
+		git_str_dispose(buf);
 
 	if (!size) {
-		git_buf_init(buf, 0);
+		git_str_init(buf, 0);
 	} else {
 		buf->ptr = (char *)ptr;
 		buf->asize = 0;
@@ -658,7 +669,7 @@ void git_buf_attach_notowned(git_buf *buf, const char *ptr, size_t size)
 	}
 }
 
-int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...)
+int git_str_join_n(git_str *buf, char separator, int nbuf, ...)
 {
 	va_list ap;
 	int i;
@@ -672,7 +683,7 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...)
 
 	va_start(ap, nbuf);
 	for (i = 0; i < nbuf; ++i) {
-		const char* segment;
+		const char *segment;
 		size_t segment_len;
 
 		segment = va_arg(ap, const char *);
@@ -693,7 +704,7 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...)
 		return 0;
 
 	GIT_ERROR_CHECK_ALLOC_ADD(&total_size, total_size, 1);
-	if (git_buf_grow_by(buf, total_size) < 0)
+	if (git_str_grow_by(buf, total_size) < 0)
 		return -1;
 
 	out = buf->ptr + buf->size;
@@ -704,7 +715,7 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...)
 
 	va_start(ap, nbuf);
 	for (i = 0; i < nbuf; ++i) {
-		const char* segment;
+		const char *segment;
 		size_t segment_len;
 
 		segment = va_arg(ap, const char *);
@@ -746,8 +757,8 @@ int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...)
 	return 0;
 }
 
-int git_buf_join(
-	git_buf *buf,
+int git_str_join(
+	git_str *buf,
 	char separator,
 	const char *str_a,
 	const char *str_b)
@@ -760,7 +771,7 @@ int git_buf_join(
 
 	/* not safe to have str_b point internally to the buffer */
 	if (buf->size)
-		assert(str_b < buf->ptr || str_b >= buf->ptr + buf->size);
+		GIT_ASSERT_ARG(str_b < buf->ptr || str_b >= buf->ptr + buf->size);
 
 	/* figure out if we need to insert a separator */
 	if (separator && strlen_a) {
@@ -795,8 +806,8 @@ int git_buf_join(
 	return 0;
 }
 
-int git_buf_join3(
-	git_buf *buf,
+int git_str_join3(
+	git_str *buf,
 	char separator,
 	const char *str_a,
 	const char *str_b,
@@ -810,9 +821,9 @@ int git_buf_join3(
 	char *tgt;
 
 	/* for this function, disallow pointers into the existing buffer */
-	assert(str_a < buf->ptr || str_a >= buf->ptr + buf->size);
-	assert(str_b < buf->ptr || str_b >= buf->ptr + buf->size);
-	assert(str_c < buf->ptr || str_c >= buf->ptr + buf->size);
+	GIT_ASSERT(str_a < buf->ptr || str_a >= buf->ptr + buf->size);
+	GIT_ASSERT(str_b < buf->ptr || str_b >= buf->ptr + buf->size);
+	GIT_ASSERT(str_c < buf->ptr || str_c >= buf->ptr + buf->size);
 
 	if (separator) {
 		if (len_a > 0) {
@@ -855,7 +866,7 @@ int git_buf_join3(
 	return 0;
 }
 
-void git_buf_rtrim(git_buf *buf)
+void git_str_rtrim(git_str *buf)
 {
 	while (buf->size > 0) {
 		if (!git__isspace(buf->ptr[buf->size - 1]))
@@ -868,15 +879,15 @@ void git_buf_rtrim(git_buf *buf)
 		buf->ptr[buf->size] = '\0';
 }
 
-int git_buf_cmp(const git_buf *a, const git_buf *b)
+int git_str_cmp(const git_str *a, const git_str *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 git_buf_splice(
-	git_buf *buf,
+int git_str_splice(
+	git_str *buf,
 	size_t where,
 	size_t nb_to_remove,
 	const char *data,
@@ -885,7 +896,9 @@ int git_buf_splice(
 	char *splice_loc;
 	size_t new_size, alloc_size;
 
-	assert(buf && where <= buf->size && nb_to_remove <= buf->size - where);
+	GIT_ASSERT(buf);
+	GIT_ASSERT(where <= buf->size);
+	GIT_ASSERT(nb_to_remove <= buf->size - where);
 
 	splice_loc = buf->ptr + where;
 
@@ -908,10 +921,10 @@ int git_buf_splice(
 }
 
 /* Quote per http://marc.info/?l=git&m=112927316408690&w=2 */
-int git_buf_quote(git_buf *buf)
+int git_str_quote(git_str *buf)
 {
 	const char whitespace[] = { 'a', 'b', 't', 'n', 'v', 'f', 'r' };
-	git_buf quoted = GIT_BUF_INIT;
+	git_str quoted = GIT_STR_INIT;
 	size_t i = 0;
 	bool quote = false;
 	int error = 0;
@@ -931,55 +944,55 @@ int git_buf_quote(git_buf *buf)
 	if (!quote)
 		goto done;
 
-	git_buf_putc(&quoted, '"');
-	git_buf_put(&quoted, buf->ptr, i);
+	git_str_putc(&quoted, '"');
+	git_str_put(&quoted, buf->ptr, i);
 
 	for (; i < buf->size; i++) {
 		/* whitespace - use the map above, which is ordered by ascii value */
 		if (buf->ptr[i] >= '\a' && buf->ptr[i] <= '\r') {
-			git_buf_putc(&quoted, '\\');
-			git_buf_putc(&quoted, whitespace[buf->ptr[i] - '\a']);
+			git_str_putc(&quoted, '\\');
+			git_str_putc(&quoted, whitespace[buf->ptr[i] - '\a']);
 		}
 
 		/* double quote and backslash must be escaped */
 		else if (buf->ptr[i] == '"' || buf->ptr[i] == '\\') {
-			git_buf_putc(&quoted, '\\');
-			git_buf_putc(&quoted, buf->ptr[i]);
+			git_str_putc(&quoted, '\\');
+			git_str_putc(&quoted, buf->ptr[i]);
 		}
 
 		/* escape anything unprintable as octal */
 		else if (buf->ptr[i] != ' ' &&
 				(buf->ptr[i] < '!' || buf->ptr[i] > '~')) {
-			git_buf_printf(&quoted, "\\%03o", (unsigned char)buf->ptr[i]);
+			git_str_printf(&quoted, "\\%03o", (unsigned char)buf->ptr[i]);
 		}
 
 		/* yay, printable! */
 		else {
-			git_buf_putc(&quoted, buf->ptr[i]);
+			git_str_putc(&quoted, buf->ptr[i]);
 		}
 	}
 
-	git_buf_putc(&quoted, '"');
+	git_str_putc(&quoted, '"');
 
-	if (git_buf_oom(&quoted)) {
+	if (git_str_oom(&quoted)) {
 		error = -1;
 		goto done;
 	}
 
-	git_buf_swap(&quoted, buf);
+	git_str_swap(&quoted, buf);
 
 done:
-	git_buf_dispose(&quoted);
+	git_str_dispose(&quoted);
 	return error;
 }
 
 /* Unquote per http://marc.info/?l=git&m=112927316408690&w=2 */
-int git_buf_unquote(git_buf *buf)
+int git_str_unquote(git_str *buf)
 {
 	size_t i, j;
 	char ch;
 
-	git_buf_rtrim(buf);
+	git_str_rtrim(buf);
 
 	if (buf->size < 2 || buf->ptr[0] != '"' || buf->ptr[buf->size-1] != '"')
 		goto invalid;
@@ -1047,3 +1060,313 @@ invalid:
 	git_error_set(GIT_ERROR_INVALID, "invalid quoted line");
 	return -1;
 }
+
+int git_str_puts_escaped(
+	git_str *buf,
+	const char *string,
+	const char *esc_chars,
+	const char *esc_with)
+{
+	const char *scan;
+	size_t total = 0, esc_len = strlen(esc_with), count, alloclen;
+
+	if (!string)
+		return 0;
+
+	for (scan = string; *scan; ) {
+		/* count run of non-escaped characters */
+		count = strcspn(scan, esc_chars);
+		total += count;
+		scan += count;
+		/* count run of escaped characters */
+		count = strspn(scan, esc_chars);
+		total += count * (esc_len + 1);
+		scan += count;
+	}
+
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, total, 1);
+	if (git_str_grow_by(buf, alloclen) < 0)
+		return -1;
+
+	for (scan = string; *scan; ) {
+		count = strcspn(scan, esc_chars);
+
+		memmove(buf->ptr + buf->size, scan, count);
+		scan += count;
+		buf->size += count;
+
+		for (count = strspn(scan, esc_chars); count > 0; --count) {
+			/* copy escape sequence */
+			memmove(buf->ptr + buf->size, esc_with, esc_len);
+			buf->size += esc_len;
+			/* copy character to be escaped */
+			buf->ptr[buf->size] = *scan;
+			buf->size++;
+			scan++;
+		}
+	}
+
+	buf->ptr[buf->size] = '\0';
+
+	return 0;
+}
+
+void git_str_unescape(git_str *buf)
+{
+	buf->size = git__unescape(buf->ptr);
+}
+
+int git_str_crlf_to_lf(git_str *tgt, const git_str *src)
+{
+	const char *scan = src->ptr;
+	const char *scan_end = src->ptr + src->size;
+	const char *next = memchr(scan, '\r', src->size);
+	size_t new_size;
+	char *out;
+
+	GIT_ASSERT(tgt != src);
+
+	if (!next)
+		return git_str_set(tgt, src->ptr, src->size);
+
+	/* reduce reallocs while in the loop */
+	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, src->size, 1);
+	if (git_str_grow(tgt, new_size) < 0)
+		return -1;
+
+	out = tgt->ptr;
+	tgt->size = 0;
+
+	/* Find the next \r and copy whole chunk up to there to tgt */
+	for (; next; scan = next + 1, next = memchr(scan, '\r', scan_end - scan)) {
+		if (next > scan) {
+			size_t copylen = (size_t)(next - scan);
+			memcpy(out, scan, copylen);
+			out += copylen;
+		}
+
+		/* Do not drop \r unless it is followed by \n */
+		if (next + 1 == scan_end || next[1] != '\n')
+			*out++ = '\r';
+	}
+
+	/* Copy remaining input into dest */
+	if (scan < scan_end) {
+		size_t remaining = (size_t)(scan_end - scan);
+		memcpy(out, scan, remaining);
+		out += remaining;
+	}
+
+	tgt->size = (size_t)(out - tgt->ptr);
+	tgt->ptr[tgt->size] = '\0';
+
+	return 0;
+}
+
+int git_str_lf_to_crlf(git_str *tgt, const git_str *src)
+{
+	const char *start = src->ptr;
+	const char *end = start + src->size;
+	const char *scan = start;
+	const char *next = memchr(scan, '\n', src->size);
+	size_t alloclen;
+
+	GIT_ASSERT(tgt != src);
+
+	if (!next)
+		return git_str_set(tgt, src->ptr, src->size);
+
+	/* attempt to reduce reallocs while in the loop */
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, src->size, src->size >> 4);
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
+	if (git_str_grow(tgt, alloclen) < 0)
+		return -1;
+	tgt->size = 0;
+
+	for (; next; scan = next + 1, next = memchr(scan, '\n', end - scan)) {
+		size_t copylen = next - scan;
+
+		/* if we find mixed line endings, carry on */
+		if (copylen && next[-1] == '\r')
+			copylen--;
+
+		GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, copylen, 3);
+		if (git_str_grow_by(tgt, alloclen) < 0)
+			return -1;
+
+		if (copylen) {
+			memcpy(tgt->ptr + tgt->size, scan, copylen);
+			tgt->size += copylen;
+		}
+
+		tgt->ptr[tgt->size++] = '\r';
+		tgt->ptr[tgt->size++] = '\n';
+	}
+
+	tgt->ptr[tgt->size] = '\0';
+	return git_str_put(tgt, scan, end - scan);
+}
+
+int git_str_common_prefix(git_str *buf, char *const *const strings, size_t count)
+{
+	size_t i;
+	const char *str, *pfx;
+
+	git_str_clear(buf);
+
+	if (!strings || !count)
+		return 0;
+
+	/* initialize common prefix to first string */
+	if (git_str_sets(buf, strings[0]) < 0)
+		return -1;
+
+	/* go through the rest of the strings, truncating to shared prefix */
+	for (i = 1; i < count; ++i) {
+
+		for (str = strings[i], pfx = buf->ptr;
+		     *str && *str == *pfx;
+		     str++, pfx++)
+			/* scanning */;
+
+		git_str_truncate(buf, pfx - buf->ptr);
+
+		if (!buf->size)
+			break;
+	}
+
+	return 0;
+}
+
+int git_str_is_binary(const git_str *buf)
+{
+	const char *scan = buf->ptr, *end = buf->ptr + buf->size;
+	git_str_bom_t bom;
+	int printable = 0, nonprintable = 0;
+
+	scan += git_str_detect_bom(&bom, buf);
+
+	if (bom > GIT_STR_BOM_UTF8)
+		return 1;
+
+	while (scan < end) {
+		unsigned char c = *scan++;
+
+		/* Printable characters are those above SPACE (0x1F) excluding DEL,
+		 * and including BS, ESC and FF.
+		 */
+		if ((c > 0x1F && c != 127) || c == '\b' || c == '\033' || c == '\014')
+			printable++;
+		else if (c == '\0')
+			return true;
+		else if (!git__isspace(c))
+			nonprintable++;
+	}
+
+	return ((printable >> 7) < nonprintable);
+}
+
+int git_str_contains_nul(const git_str *buf)
+{
+	return (memchr(buf->ptr, '\0', buf->size) != NULL);
+}
+
+int git_str_detect_bom(git_str_bom_t *bom, const git_str *buf)
+{
+	const char *ptr;
+	size_t len;
+
+	*bom = GIT_STR_BOM_NONE;
+	/* need at least 2 bytes to look for any BOM */
+	if (buf->size < 2)
+		return 0;
+
+	ptr = buf->ptr;
+	len = buf->size;
+
+	switch (*ptr++) {
+	case 0:
+		if (len >= 4 && ptr[0] == 0 && ptr[1] == '\xFE' && ptr[2] == '\xFF') {
+			*bom = GIT_STR_BOM_UTF32_BE;
+			return 4;
+		}
+		break;
+	case '\xEF':
+		if (len >= 3 && ptr[0] == '\xBB' && ptr[1] == '\xBF') {
+			*bom = GIT_STR_BOM_UTF8;
+			return 3;
+		}
+		break;
+	case '\xFE':
+		if (*ptr == '\xFF') {
+			*bom = GIT_STR_BOM_UTF16_BE;
+			return 2;
+		}
+		break;
+	case '\xFF':
+		if (*ptr != '\xFE')
+			break;
+		if (len >= 4 && ptr[1] == 0 && ptr[2] == 0) {
+			*bom = GIT_STR_BOM_UTF32_LE;
+			return 4;
+		} else {
+			*bom = GIT_STR_BOM_UTF16_LE;
+			return 2;
+		}
+		break;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+bool git_str_gather_text_stats(
+	git_str_text_stats *stats, const git_str *buf, bool skip_bom)
+{
+	const char *scan = buf->ptr, *end = buf->ptr + buf->size;
+	int skip;
+
+	memset(stats, 0, sizeof(*stats));
+
+	/* BOM detection */
+	skip = git_str_detect_bom(&stats->bom, buf);
+	if (skip_bom)
+		scan += skip;
+
+	/* Ignore EOF character */
+	if (buf->size > 0 && end[-1] == '\032')
+		end--;
+
+	/* Counting loop */
+	while (scan < end) {
+		unsigned char c = *scan++;
+
+		if (c > 0x1F && c != 0x7F)
+			stats->printable++;
+		else switch (c) {
+			case '\0':
+				stats->nul++;
+				stats->nonprintable++;
+				break;
+			case '\n':
+				stats->lf++;
+				break;
+			case '\r':
+				stats->cr++;
+				if (scan < end && *scan == '\n')
+					stats->crlf++;
+				break;
+			case '\t': case '\f': case '\v': case '\b': case 0x1b: /*ESC*/
+				stats->printable++;
+				break;
+			default:
+				stats->nonprintable++;
+				break;
+			}
+	}
+
+	/* Treat files with a bare CR as binary */
+	return (stats->cr != stats->crlf || stats->nul > 0 ||
+		((stats->printable >> 7) < stats->nonprintable));
+}