rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/src/unix/posix.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_posix__w32_h__
+#define INCLUDE_posix__w32_h__
+
+#include <fnmatch.h>
+
+#define p_lstat(p,b) lstat(p,b)
+#define p_readlink(a, b, c) readlink(a, b, c)
+#define p_link(o,n) link(o, n)
+#define p_unlink(p) unlink(p)
+#define p_mkdir(p,m) mkdir(p, m)
+#define p_fsync(fd) fsync(fd)
+#define p_realpath(p, po) realpath(p, po)
+#define p_fnmatch(p, s, f) fnmatch(p, s, f)
+#define p_vsnprintf(b, c, f, a) vsnprintf(b, c, f, a)
+#define p_snprintf(b, c, f, ...) snprintf(b, c, f, __VA_ARGS__)
+#define p_mkstemp(p) mkstemp(p)
+#define p_setenv(n,v,o) setenv(n,v,o)
+
+#endif

data/ext/rugged/vendor/libgit2-dist/src/util.c

@@ -0,0 +1,381 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * 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 <git2.h>
+#include "common.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <ctype.h>
+#include "posix.h"
+
+#ifdef _MSC_VER
+# include <Shlwapi.h>
+#endif
+
+void git_libgit2_version(int *major, int *minor, int *rev)
+{
+	*major = LIBGIT2_VER_MAJOR;
+	*minor = LIBGIT2_VER_MINOR;
+	*rev = LIBGIT2_VER_REVISION;
+}
+
+void git_strarray_free(git_strarray *array)
+{
+	size_t i;
+	for (i = 0; i < array->count; ++i)
+		git__free(array->strings[i]);
+
+	git__free(array->strings);
+}
+
+int git__fnmatch(const char *pattern, const char *name, int flags)
+{
+	int ret;
+
+	ret = p_fnmatch(pattern, name, flags);
+	switch (ret) {
+	case 0:
+		return GIT_SUCCESS;
+	case FNM_NOMATCH:
+		return GIT_ENOMATCH;
+	default:
+		return git__throw(GIT_EOSERR, "Error trying to match path");
+	}
+}
+
+int git__strtol64(int64_t *result, const char *nptr, const char **endptr, int base)
+{
+	const char *p;
+	int64_t n, nn;
+	int c, ovfl, v, neg, ndig;
+
+	p = nptr;
+	neg = 0;
+	n = 0;
+	ndig = 0;
+	ovfl = 0;
+
+	/*
+	 * White space
+	 */
+	while (isspace(*p))
+		p++;
+
+	/*
+	 * Sign
+	 */
+	if (*p == '-' || *p == '+')
+		if (*p++ == '-')
+			neg = 1;
+
+	/*
+	 * Base
+	 */
+	if (base == 0) {
+		if (*p != '0')
+			base = 10;
+		else {
+			base = 8;
+			if (p[1] == 'x' || p[1] == 'X') {
+				p += 2;
+				base = 16;
+			}
+		}
+	} else if (base == 16 && *p == '0') {
+		if (p[1] == 'x' || p[1] == 'X')
+			p += 2;
+	} else if (base < 0 || 36 < base)
+		goto Return;
+
+	/*
+	 * Non-empty sequence of digits
+	 */
+	for (;; p++,ndig++) {
+		c = *p;
+		v = base;
+		if ('0'<=c && c<='9')
+			v = c - '0';
+		else if ('a'<=c && c<='z')
+			v = c - 'a' + 10;
+		else if ('A'<=c && c<='Z')
+			v = c - 'A' + 10;
+		if (v >= base)
+			break;
+		nn = n*base + v;
+		if (nn < n)
+			ovfl = 1;
+		n = nn;
+	}
+
+Return:
+	if (ndig == 0)
+		return git__throw(GIT_ENOTNUM, "Failed to convert string to long. Not a number");
+
+	if (endptr)
+		*endptr = p;
+
+	if (ovfl)
+		return git__throw(GIT_EOVERFLOW, "Failed to convert string to long. Overflow error");
+
+	*result = neg ? -n : n;
+	return GIT_SUCCESS;
+}
+
+int git__strtol32(int32_t *result, const char *nptr, const char **endptr, int base)
+{
+	int error = GIT_SUCCESS;
+	int32_t tmp_int;
+	int64_t tmp_long;
+
+	if ((error = git__strtol64(&tmp_long, nptr, endptr, base)) < GIT_SUCCESS)
+		return error;
+
+	tmp_int = tmp_long & 0xFFFFFFFF;
+	if (tmp_int != tmp_long)
+		return git__throw(GIT_EOVERFLOW, "Failed to convert. '%s' is too large", nptr);
+
+	*result = tmp_int;
+	
+	return error;
+}
+
+void git__strntolower(char *str, size_t len)
+{
+	size_t i;
+
+	for (i = 0; i < len; ++i) {
+		str[i] = (char) tolower(str[i]);
+	}
+}
+
+void git__strtolower(char *str)
+{
+	git__strntolower(str, strlen(str));
+}
+
+int git__prefixcmp(const char *str, const char *prefix)
+{
+	for (;;) {
+		char p = *(prefix++), s;
+		if (!p)
+			return 0;
+		if ((s = *(str++)) != p)
+			return s - p;
+	}
+}
+
+int git__suffixcmp(const char *str, const char *suffix)
+{
+	size_t a = strlen(str);
+	size_t b = strlen(suffix);
+	if (a < b)
+		return -1;
+	return strcmp(str + (a - b), suffix);
+}
+
+char *git__strtok(char **end, const char *sep)
+{
+	char *ptr = *end;
+
+	while (*ptr && strchr(sep, *ptr))
+		++ptr;
+
+	if (*ptr) {
+		char *start = ptr;
+		*end = start + 1;
+
+		while (**end && !strchr(sep, **end))
+			++*end;
+
+		if (**end) {
+			**end = '\0';
+			++*end;
+		}
+
+		return start;
+	}
+
+	return NULL;
+}
+
+void git__hexdump(const char *buffer, size_t len)
+{
+	static const size_t LINE_WIDTH = 16;
+
+	size_t line_count, last_line, i, j;
+	const char *line;
+
+	line_count = (len / LINE_WIDTH);
+	last_line = (len % LINE_WIDTH);
+
+	for (i = 0; i < line_count; ++i) {
+		line = buffer + (i * LINE_WIDTH);
+		for (j = 0; j < LINE_WIDTH; ++j, ++line)
+			printf("%02X ", (unsigned char)*line & 0xFF);
+
+		printf("| ");
+
+		line = buffer + (i * LINE_WIDTH);
+		for (j = 0; j < LINE_WIDTH; ++j, ++line)
+			printf("%c", (*line >= 32 && *line <= 126) ? *line : '.');
+
+		printf("\n");
+	}
+
+	if (last_line > 0) {
+
+		line = buffer + (line_count * LINE_WIDTH);
+		for (j = 0; j < last_line; ++j, ++line)
+			printf("%02X ", (unsigned char)*line & 0xFF);
+
+		for (j = 0; j < (LINE_WIDTH - last_line); ++j)
+			printf("	");
+
+		printf("| ");
+
+		line = buffer + (line_count * LINE_WIDTH);
+		for (j = 0; j < last_line; ++j, ++line)
+			printf("%c", (*line >= 32 && *line <= 126) ? *line : '.');
+
+		printf("\n");
+	}
+
+	printf("\n");
+}
+
+#ifdef GIT_LEGACY_HASH
+uint32_t git__hash(const void *key, int len, unsigned int seed)
+{
+	const uint32_t m = 0x5bd1e995;
+	const int r = 24;
+	uint32_t h = seed ^ len;
+
+	const unsigned char *data = (const unsigned char *)key;
+
+	while(len >= 4) {
+		uint32_t k = *(uint32_t *)data;
+
+		k *= m;
+		k ^= k >> r;
+		k *= m;
+
+		h *= m;
+		h ^= k;
+
+		data += 4;
+		len -= 4;
+	}
+
+	switch(len) {
+	case 3: h ^= data[2] << 16;
+	case 2: h ^= data[1] << 8;
+	case 1: h ^= data[0];
+			h *= m;
+	};
+
+	h ^= h >> 13;
+	h *= m;
+	h ^= h >> 15;
+
+	return h;
+}
+#else
+/*
+	Cross-platform version of Murmurhash3
+	http://code.google.com/p/smhasher/wiki/MurmurHash3
+	by Austin Appleby (aappleby@gmail.com)
+
+	This code is on the public domain.
+*/
+uint32_t git__hash(const void *key, int len, uint32_t seed)
+{
+
+#define MURMUR_BLOCK() {\
+	k1 *= c1; \
+	k1 = git__rotl(k1,11);\
+	k1 *= c2;\
+	h1 ^= k1;\
+	h1 = h1*3 + 0x52dce729;\
+	c1 = c1*5 + 0x7b7d159c;\
+	c2 = c2*5 + 0x6bce6396;\
+}
+
+	const uint8_t *data = (const uint8_t*)key;
+	const int nblocks = len / 4;
+
+	const uint32_t *blocks = (const uint32_t *)(data + nblocks * 4);
+	const uint8_t *tail = (const uint8_t *)(data + nblocks * 4);
+
+	uint32_t h1 = 0x971e137b ^ seed;
+	uint32_t k1;
+
+	uint32_t c1 = 0x95543787;
+	uint32_t c2 = 0x2ad7eb25;
+
+	int i;
+
+	for (i = -nblocks; i; i++) {
+		k1 = blocks[i];
+		MURMUR_BLOCK();
+	}
+
+	k1 = 0;
+
+	switch(len & 3) {
+	case 3: k1 ^= tail[2] << 16;
+	case 2: k1 ^= tail[1] << 8;
+	case 1: k1 ^= tail[0];
+			MURMUR_BLOCK();
+	}
+
+	h1 ^= len;
+	h1 ^= h1 >> 16;
+	h1 *= 0x85ebca6b;
+	h1 ^= h1 >> 13;
+	h1 *= 0xc2b2ae35;
+	h1 ^= h1 >> 16;
+
+	return h1;
+}
+#endif
+
+/**
+ * A modified `bsearch` from the BSD glibc.
+ *
+ * Copyright (c) 1990 Regents of the University of California.
+ * All rights reserved.
+ */
+void **git__bsearch(const void *key, void **base, size_t nmemb, int (*compar)(const void *, const void *))
+{
+		int lim, cmp;
+		void **p;
+
+		for (lim = nmemb; lim != 0; lim >>= 1) {
+				p = base + (lim >> 1);
+				cmp = (*compar)(key, *p);
+				if (cmp > 0) { /* key > p: move right */
+						base = p + 1;
+						lim--;
+				} else if (cmp == 0) {
+						return (void **)p;
+				} /* else move left */
+		}
+		return NULL;
+}
+
+/**
+ * A strcmp wrapper
+ * 
+ * We don't want direct pointers to the CRT on Windows, we may
+ * get stdcall conflicts.
+ */
+int git__strcmp_cb(const void *a, const void *b)
+{
+	const char *stra = (const char *)a;
+	const char *strb = (const char *)b;
+
+	return strcmp(stra, strb);
+}

data/ext/rugged/vendor/libgit2-dist/src/util.h

@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_util_h__
+#define INCLUDE_util_h__
+
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
+#define bitsizeof(x) (CHAR_BIT * sizeof(x))
+#define MSB(x, bits) ((x) & (~0ULL << (bitsizeof(x) - (bits))))
+#ifndef min
+# define min(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+/*
+ * Custom memory allocation wrappers
+ * that set error code and error message
+ * on allocation failure
+ */
+GIT_INLINE(void *) git__malloc(size_t len)
+{
+	void *ptr = malloc(len);
+	if (!ptr)
+		git__throw(GIT_ENOMEM, "Out of memory. Failed to allocate %d bytes.", (int)len);
+	return ptr;
+}
+
+GIT_INLINE(void *) git__calloc(size_t nelem, size_t elsize)
+{
+	void *ptr = calloc(nelem, elsize);
+	if (!ptr)
+		git__throw(GIT_ENOMEM, "Out of memory. Failed to allocate %d bytes.", (int)elsize);
+	return ptr;
+}
+
+GIT_INLINE(char *) git__strdup(const char *str)
+{
+	char *ptr = strdup(str);
+	if (!ptr)
+		git__throw(GIT_ENOMEM, "Out of memory. Failed to duplicate string");
+	return ptr;
+}
+
+GIT_INLINE(char *) git__strndup(const char *str, size_t n)
+{
+	size_t length;
+	char *ptr;
+
+	length = strlen(str);
+	if (n < length)
+		length = n;
+
+	ptr = (char*)malloc(length + 1);
+	if (!ptr) {
+		git__throw(GIT_ENOMEM, "Out of memory. Failed to duplicate string");
+		return NULL;
+	}
+
+	memcpy(ptr, str, length);
+	ptr[length] = '\0';
+
+	return ptr;
+}
+
+GIT_INLINE(void *) git__realloc(void *ptr, size_t size)
+{
+	void *new_ptr = realloc(ptr, size);
+	if (!new_ptr)
+		git__throw(GIT_ENOMEM, "Out of memory. Failed to allocate %d bytes.", (int)size);
+	return new_ptr;
+}
+
+#define git__free(ptr) free(ptr)
+
+extern int git__prefixcmp(const char *str, const char *prefix);
+extern int git__suffixcmp(const char *str, const char *suffix);
+
+extern int git__strtol32(int32_t *n, const char *buff, const char **end_buf, int base);
+extern int git__strtol64(int64_t *n, const char *buff, const char **end_buf, int base);
+
+extern void git__hexdump(const char *buffer, size_t n);
+extern uint32_t git__hash(const void *key, int len, uint32_t seed);
+
+/** @return true if p fits into the range of a size_t */
+GIT_INLINE(int) git__is_sizet(git_off_t p)
+{
+	size_t r = (size_t)p;
+	return p == (git_off_t)r;
+}
+
+/* 32-bit cross-platform rotl */
+#ifdef _MSC_VER /* use built-in method in MSVC */
+#	define git__rotl(v, s) (uint32_t)_rotl(v, s)
+#else /* use bitops in GCC; with o2 this gets optimized to a rotl instruction */
+#	define git__rotl(v, s) (uint32_t)(((uint32_t)(v) << (s)) | ((uint32_t)(v) >> (32 - (s))))
+#endif
+
+extern char *git__strtok(char **end, const char *sep);
+
+extern void git__strntolower(char *str, size_t len);
+extern void git__strtolower(char *str);
+
+extern int git__fnmatch(const char *pattern, const char *name, int flags);
+
+extern void git__tsort(void **dst, size_t size, int (*cmp)(const void *, const void *));
+extern void **git__bsearch(const void *key, void **base, size_t nmemb,
+	int (*compar)(const void *, const void *));
+
+extern int git__strcmp_cb(const void *a, const void *b);
+
+typedef struct {
+	short refcount;
+	void *owner;
+} git_refcount;
+
+typedef void (*git_refcount_freeptr)(void *r);
+
+#define GIT_REFCOUNT_INC(r) { \
+	((git_refcount *)(r))->refcount++; \
+}
+
+#define GIT_REFCOUNT_DEC(_r, do_free) { \
+	git_refcount *r = (git_refcount *)(_r); \
+	r->refcount--; \
+	if (r->refcount <= 0 && r->owner == NULL) { do_free(_r); } \
+}
+
+#define GIT_REFCOUNT_OWN(r, o) { \
+	((git_refcount *)(r))->owner = o; \
+}
+
+#define GIT_REFCOUNT_OWNER(r) (((git_refcount *)(r))->owner)
+
+
+#endif /* INCLUDE_util_h__ */