rugged 0.1.2 → 0.16.0b1

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

@@ -0,0 +1,97 @@
+/*
+ * 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 "common.h"
+
+/*
+ * Default version that the compiler ought to optimize properly with
+ * constant values.
+ */
+GIT_INLINE(uint32_t) default_swab32(uint32_t val)
+{
+	return (((val & 0xff000000) >> 24) |
+		((val & 0x00ff0000) >> 8) |
+		((val & 0x0000ff00) << 8) |
+		((val & 0x000000ff) << 24));
+}
+
+#undef bswap32
+
+GIT_INLINE(uint16_t) default_swab16(uint16_t val)
+{
+	return (((val & 0xff00) >> 8) |
+		((val & 0x00ff) << 8));
+}
+
+#undef bswap16
+
+#if defined(__GNUC__) && defined(__i386__)
+
+#define bswap32(x) ({ \
+	uint32_t __res; \
+	if (__builtin_constant_p(x)) { \
+		__res = default_swab32(x); \
+	} else { \
+		__asm__("bswap %0" : "=r" (__res) : "0" ((uint32_t)(x))); \
+	} \
+	__res; })
+
+#define bswap16(x) ({ \
+	uint16_t __res; \
+	if (__builtin_constant_p(x)) { \
+		__res = default_swab16(x); \
+	} else { \
+		__asm__("xchgb %b0,%h0" : "=q" (__res) : "0" ((uint16_t)(x))); \
+	} \
+	__res; })
+
+#elif defined(__GNUC__) && defined(__x86_64__)
+
+#define bswap32(x) ({ \
+	uint32_t __res; \
+	if (__builtin_constant_p(x)) { \
+		__res = default_swab32(x); \
+	} else { \
+		__asm__("bswapl %0" : "=r" (__res) : "0" ((uint32_t)(x))); \
+	} \
+	__res; })
+
+#define bswap16(x) ({ \
+	uint16_t __res; \
+	if (__builtin_constant_p(x)) { \
+		__res = default_swab16(x); \
+	} else { \
+		__asm__("xchgb %b0,%h0" : "=Q" (__res) : "0" ((uint16_t)(x))); \
+	} \
+	__res; })
+
+#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
+
+#include <stdlib.h>
+
+#define bswap32(x) _byteswap_ulong(x)
+#define bswap16(x) _byteswap_ushort(x)
+
+#endif
+
+#ifdef bswap32
+
+#undef ntohl
+#undef htonl
+#define ntohl(x) bswap32(x)
+#define htonl(x) bswap32(x)
+
+#endif
+
+#ifdef bswap16
+
+#undef ntohs
+#undef htons
+#define ntohs(x) bswap16(x)
+#define htons(x) bswap16(x)
+
+#endif

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

@@ -0,0 +1,113 @@
+/*
+ * 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 "buffer.h"
+#include "posix.h"
+#include <stdarg.h>
+
+#define ENSURE_SIZE(b, d) \
+	if ((ssize_t)(d) >= buf->asize && git_buf_grow(b, (d)) < GIT_SUCCESS)\
+		return;
+
+int git_buf_grow(git_buf *buf, size_t target_size)
+{
+	char *new_ptr;
+
+	if (buf->asize < 0)
+		return GIT_ENOMEM;
+
+	if (buf->asize == 0)
+		buf->asize = target_size;
+
+	/* grow the buffer size by 1.5, until it's big enough
+	 * to fit our target size */
+	while (buf->asize < (int)target_size)
+		buf->asize = (buf->asize << 1) - (buf->asize >> 1);
+
+	new_ptr = git__realloc(buf->ptr, buf->asize);
+	if (!new_ptr) {
+		buf->asize = -1;
+		return GIT_ENOMEM;
+	}
+
+	buf->ptr = new_ptr;
+	return GIT_SUCCESS;
+}
+
+int git_buf_oom(const git_buf *buf)
+{
+	return (buf->asize < 0);
+}
+
+void git_buf_putc(git_buf *buf, char c)
+{
+	ENSURE_SIZE(buf, buf->size + 1);
+	buf->ptr[buf->size++] = c;
+}
+
+void git_buf_put(git_buf *buf, const char *data, size_t len)
+{
+	ENSURE_SIZE(buf, buf->size + len);
+	memcpy(buf->ptr + buf->size, data, len);
+	buf->size += len;
+}
+
+void git_buf_puts(git_buf *buf, const char *string)
+{
+	git_buf_put(buf, string, strlen(string));
+}
+
+void git_buf_printf(git_buf *buf, const char *format, ...)
+{
+	int len;
+	va_list arglist;
+
+	ENSURE_SIZE(buf, buf->size + 1);
+
+	while (1) {
+		va_start(arglist, format);
+		len = p_vsnprintf(buf->ptr + buf->size, buf->asize - buf->size, format, arglist);
+		va_end(arglist);
+
+		if (len < 0) {
+			buf->asize = -1;
+			return;
+		}
+
+		if (len + 1 <= buf->asize - buf->size) {
+			buf->size += len;
+			return;
+		}
+
+		ENSURE_SIZE(buf, buf->size + len + 1);
+	}
+}
+
+const char *git_buf_cstr(git_buf *buf)
+{
+	if (buf->size + 1 >= buf->asize && git_buf_grow(buf, buf->size + 1) < GIT_SUCCESS)
+		return NULL;
+
+	buf->ptr[buf->size] = '\0';
+	return buf->ptr;
+}
+
+void git_buf_free(git_buf *buf)
+{
+	git__free(buf->ptr);
+}
+
+void git_buf_clear(git_buf *buf)
+{
+	buf->size = 0;
+}
+
+void git_buf_consume(git_buf *buf, const char *end)
+{
+	size_t consumed = end - buf->ptr;
+	memmove(buf->ptr, end, buf->size - consumed);
+	buf->size -= consumed;
+}

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

@@ -0,0 +1,32 @@
+/*
+ * 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_buffer_h__
+#define INCLUDE_buffer_h__
+
+#include "common.h"
+
+typedef struct {
+	char *ptr;
+	ssize_t asize, size;
+} git_buf;
+
+#define GIT_BUF_INIT {NULL, 0, 0}
+
+int git_buf_grow(git_buf *buf, size_t target_size);
+int git_buf_oom(const git_buf *buf);
+void git_buf_putc(git_buf *buf, char c);
+void git_buf_put(git_buf *buf, const char *data, size_t len);
+void git_buf_puts(git_buf *buf, const char *string);
+void git_buf_printf(git_buf *buf, const char *format, ...) GIT_FORMAT_PRINTF(2, 3);
+const char *git_buf_cstr(git_buf *buf);
+void git_buf_free(git_buf *buf);
+void git_buf_clear(git_buf *buf);
+void git_buf_consume(git_buf *buf, const char *end);
+
+#define git_buf_PUTS(buf, str) git_buf_put(buf, str, sizeof(str) - 1)
+
+#endif

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

@@ -0,0 +1,111 @@
+/*
+ * 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 "common.h"
+#include "repository.h"
+#include "commit.h"
+#include "thread-utils.h"
+#include "cache.h"
+
+int git_cache_init(git_cache *cache, size_t size, git_cached_obj_freeptr free_ptr)
+{
+	size_t i;
+
+	if (size < 8)
+		size = 8;
+
+	/* round up size to closest power of 2 */
+	size--;
+	size |= size >> 1;
+	size |= size >> 2;
+	size |= size >> 4;
+	size |= size >> 8;
+	size |= size >> 16;
+
+	cache->size_mask = size;
+	cache->lru_count = 0;
+	cache->free_obj = free_ptr;
+
+	cache->nodes = git__malloc((size + 1) * sizeof(cache_node));
+	if (cache->nodes == NULL)
+		return GIT_ENOMEM;
+
+	for (i = 0; i < (size + 1); ++i) {
+		git_mutex_init(&cache->nodes[i].lock);
+		cache->nodes[i].ptr = NULL;
+	}
+
+	return GIT_SUCCESS;
+}
+
+void git_cache_free(git_cache *cache)
+{
+	size_t i;
+
+	for (i = 0; i < (cache->size_mask + 1); ++i) {
+		if (cache->nodes[i].ptr)
+			git_cached_obj_decref(cache->nodes[i].ptr, cache->free_obj);
+
+		git_mutex_free(&cache->nodes[i].lock);
+	}
+
+	git__free(cache->nodes);
+}
+
+void *git_cache_get(git_cache *cache, const git_oid *oid)
+{
+	uint32_t hash;
+	cache_node *node = NULL;
+	void *result = NULL;
+
+	memcpy(&hash, oid->id, sizeof(hash));
+	node = &cache->nodes[hash & cache->size_mask];
+
+	git_mutex_lock(&node->lock);
+	{
+		if (node->ptr && git_cached_obj_compare(node->ptr, oid) == 0) {
+			git_cached_obj_incref(node->ptr);
+			result = node->ptr;
+		}
+	}
+	git_mutex_unlock(&node->lock);
+
+	return result;
+}
+
+void *git_cache_try_store(git_cache *cache, void *entry)
+{
+	uint32_t hash;
+	const git_oid *oid;
+	cache_node *node = NULL;
+
+	oid = &((git_cached_obj*)entry)->oid;
+	memcpy(&hash, oid->id, sizeof(hash));
+	node = &cache->nodes[hash & cache->size_mask];
+
+	/* increase the refcount on this object, because
+	 * the cache now owns it */
+	git_cached_obj_incref(entry);
+	git_mutex_lock(&node->lock);
+
+	if (node->ptr == NULL) {
+		node->ptr = entry;
+	} else if (git_cached_obj_compare(node->ptr, oid) == 0) {
+		git_cached_obj_decref(entry, cache->free_obj);
+		entry = node->ptr;
+	} else {
+		git_cached_obj_decref(node->ptr, cache->free_obj);
+		node->ptr = entry;
+	}
+
+	/* increase the refcount again, because we are
+	 * returning it to the user */
+	git_cached_obj_incref(entry);
+	git_mutex_unlock(&node->lock);
+
+	return entry;
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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_cache_h__
+#define INCLUDE_cache_h__
+
+#include "git2/common.h"
+#include "git2/oid.h"
+#include "git2/odb.h"
+
+#include "thread-utils.h"
+
+#define GIT_DEFAULT_CACHE_SIZE 128
+
+typedef void (*git_cached_obj_freeptr)(void *);
+
+typedef struct {
+	git_oid oid;
+	git_atomic refcount;
+} git_cached_obj;
+
+typedef struct {
+	git_cached_obj *ptr;
+	git_mutex lock;
+} cache_node;
+
+typedef struct {
+	cache_node *nodes;
+
+	unsigned int lru_count;
+	size_t size_mask;
+	git_cached_obj_freeptr free_obj;
+} git_cache;
+
+
+int git_cache_init(git_cache *cache, size_t size, git_cached_obj_freeptr free_ptr);
+void git_cache_free(git_cache *cache);
+
+void *git_cache_try_store(git_cache *cache, void *entry);
+void *git_cache_get(git_cache *cache, const git_oid *oid);
+
+
+GIT_INLINE(int) git_cached_obj_compare(git_cached_obj *obj, const git_oid *oid)
+{
+	return git_oid_cmp(&obj->oid, oid);
+}
+
+GIT_INLINE(void) git_cached_obj_incref(git_cached_obj *obj)
+{
+	git_atomic_inc(&obj->refcount);
+}
+
+GIT_INLINE(void) git_cached_obj_decref(git_cached_obj *obj, git_cached_obj_freeptr free_obj)
+{
+	if (git_atomic_dec(&obj->refcount) == 0)
+		free_obj(obj);
+}
+
+
+
+#endif

data/ext/rugged/vendor/libgit2-dist/src/cc-compat.h

@@ -0,0 +1,67 @@
+/*
+ * 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_compat_h__
+#define INCLUDE_compat_h__
+
+/*
+ * See if our compiler is known to support flexible array members.
+ */
+#ifndef GIT_FLEX_ARRAY
+#	if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+#		define GIT_FLEX_ARRAY /* empty */
+#	elif defined(__GNUC__)
+#		if (__GNUC__ >= 3)
+#			define GIT_FLEX_ARRAY /* empty */
+#		else
+#			define GIT_FLEX_ARRAY 0 /* older GNU extension */
+#		endif
+#	endif
+
+/* Default to safer but a bit wasteful traditional style */
+#	ifndef GIT_FLEX_ARRAY
+#		define GIT_FLEX_ARRAY 1
+#	endif
+#endif
+
+#ifdef __GNUC__
+#	define GIT_TYPEOF(x) (__typeof__(x))
+#else
+#	define GIT_TYPEOF(x)
+#endif
+
+#ifdef __cplusplus
+#	define GIT_UNUSED(x)
+#else
+#	ifdef __GNUC__
+#		define GIT_UNUSED(x) x __attribute__ ((__unused__))
+#	else
+#		define GIT_UNUSED(x) x
+#	endif
+#endif
+
+#if defined(_MSC_VER)
+#define GIT_UNUSED_ARG(x) ((void)(x)); /* note trailing ; */
+#else
+#define GIT_UNUSED_ARG(x)
+#endif
+
+/* Define the printf format specifer to use for size_t output */
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#	define PRIuZ "Iu"
+#else
+#	define PRIuZ "zu"
+#endif
+
+/* Micosoft Visual C/C++ */
+#if defined(_MSC_VER)
+/* disable "deprecated function" warnings */
+#	pragma warning ( disable : 4996 )
+/* disable "conditional expression is constant" level 4 warnings */
+#	pragma warning ( disable : 4127 )
+#endif
+
+#endif /* INCLUDE_compat_h__ */