rugged 0.24.6.1 → 0.25.0b1

data/vendor/libgit2/src/tree.h

@@ -17,14 +17,15 @@
 struct git_tree_entry {
 	uint16_t attr;
 	uint16_t filename_len;
-	const git_oid *oid;
-	const char *filename;
+	git_oid oid;
+	bool pooled;
+	char filename[GIT_FLEX_ARRAY];
 };
 
 struct git_tree {
 	git_object object;
-	git_odb_object *odb_obj;
-	git_array_t(git_tree_entry) entries;
+	git_vector entries;
+	git_pool pool;
 };
 
 struct git_treebuilder {

data/vendor/libgit2/src/unix/map.c

@@ -24,11 +24,6 @@ int git__page_size(size_t *page_size)
 	return 0;
 }
 
-int git__mmap_alignment(size_t *alignment)
-{
-  return git__page_size(alignment);
-}
-
 int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset)
 {
 	int mprot = PROT_READ;

data/vendor/libgit2/src/util.c

@@ -122,8 +122,8 @@ int git__strtol64(int64_t *result, const char *nptr, const char **endptr, int ba
 			v = c - 'A' + 10;
 		if (v >= base)
 			break;
-		nn = n * base + (neg ? -v : v);
-		if ((!neg && nn < n) || (neg && nn > n))
+		nn = n*base + v;
+		if (nn < n)
 			ovfl = 1;
 		n = nn;
 	}
@@ -142,7 +142,7 @@ Return:
 		return -1;
 	}
 
-	*result = n;
+	*result = neg ? -n : n;
 	return 0;
 }
 

data/vendor/libgit2/src/win32/map.c

@@ -17,41 +17,22 @@ static DWORD get_page_size(void)
 
 	if (!page_size) {
 		GetSystemInfo(&sys);
-		page_size = sys.dwPageSize;
+		page_size = sys.dwAllocationGranularity;
 	}
 
 	return page_size;
 }
 
-static DWORD get_allocation_granularity(void)
-{
-	static DWORD granularity;
-	SYSTEM_INFO sys;
-
-	if (!granularity) {
-		GetSystemInfo(&sys);
-		granularity = sys.dwAllocationGranularity;
-	}
-
-	return granularity;
-}
-
 int git__page_size(size_t *page_size)
 {
 	*page_size = get_page_size();
 	return 0;
 }
 
-int git__mmap_alignment(size_t *page_size)
-{
-	*page_size = get_allocation_granularity();
-	return 0;
-}
-
 int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset)
 {
 	HANDLE fh = (HANDLE)_get_osfhandle(fd);
-	DWORD alignment = get_allocation_granularity();
+	DWORD page_size = get_page_size();
 	DWORD fmap_prot = 0;
 	DWORD view_prot = 0;
 	DWORD off_low = 0;
@@ -81,12 +62,12 @@ int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offs
 	if (prot & GIT_PROT_READ)
 		view_prot |= FILE_MAP_READ;
 
-	page_start = (offset / alignment) * alignment;
+	page_start = (offset / page_size) * page_size;
 	page_offset = offset - page_start;
 
-	if (page_offset != 0) { /* offset must be multiple of the allocation granularity */
+	if (page_offset != 0) { /* offset must be multiple of page size */
 		errno = EINVAL;
-		giterr_set(GITERR_OS, "Failed to mmap. Offset must be multiple of allocation granularity");
+		giterr_set(GITERR_OS, "Failed to mmap. Offset must be multiple of page size");
 		return -1;
 	}
 

data/vendor/libgit2/src/win32/precompiled.h

@@ -16,7 +16,7 @@
 #include <io.h>
 #include <direct.h>
 #ifdef GIT_THREADS
- #include "win32/thread.h"
+ #include "win32/pthread.h"
 #endif
 
 #include "git2.h"

data/vendor/libgit2/src/win32/{thread.c → pthread.c}

@@ -5,26 +5,18 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "thread.h"
+#include "pthread.h"
 #include "../global.h"
 
 #define CLEAN_THREAD_EXIT 0x6F012842
 
-typedef void (WINAPI *win32_srwlock_fn)(GIT_SRWLOCK *);
-
-static win32_srwlock_fn win32_srwlock_initialize;
-static win32_srwlock_fn win32_srwlock_acquire_shared;
-static win32_srwlock_fn win32_srwlock_release_shared;
-static win32_srwlock_fn win32_srwlock_acquire_exclusive;
-static win32_srwlock_fn win32_srwlock_release_exclusive;
-
 /* The thread procedure stub used to invoke the caller's procedure
  * and capture the return value for later collection. Windows will
  * only hold a DWORD, but we need to be able to store an entire
  * void pointer. This requires the indirection. */
 static DWORD WINAPI git_win32__threadproc(LPVOID lpParameter)
 {
-	git_thread *thread = lpParameter;
+	git_win32_thread *thread = lpParameter;
 
 	thread->result = thread->proc(thread->param);
 
@@ -33,31 +25,14 @@ static DWORD WINAPI git_win32__threadproc(LPVOID lpParameter)
 	return CLEAN_THREAD_EXIT;
 }
 
-int git_threads_init(void)
-{
-	HMODULE hModule = GetModuleHandleW(L"kernel32");
-
-	if (hModule) {
-		win32_srwlock_initialize = (win32_srwlock_fn)
-			GetProcAddress(hModule, "InitializeSRWLock");
-		win32_srwlock_acquire_shared = (win32_srwlock_fn)
-			GetProcAddress(hModule, "AcquireSRWLockShared");
-		win32_srwlock_release_shared = (win32_srwlock_fn)
-			GetProcAddress(hModule, "ReleaseSRWLockShared");
-		win32_srwlock_acquire_exclusive = (win32_srwlock_fn)
-			GetProcAddress(hModule, "AcquireSRWLockExclusive");
-		win32_srwlock_release_exclusive = (win32_srwlock_fn)
-			GetProcAddress(hModule, "ReleaseSRWLockExclusive");
-	}
-
-	return 0;
-}
-
-int git_thread_create(
-	git_thread *GIT_RESTRICT thread,
+int git_win32__thread_create(
+	git_win32_thread *GIT_RESTRICT thread,
+	const pthread_attr_t *GIT_RESTRICT attr,
 	void *(*start_routine)(void*),
 	void *GIT_RESTRICT arg)
 {
+	GIT_UNUSED(attr);
+
 	thread->result = NULL;
 	thread->param = arg;
 	thread->proc = start_routine;
@@ -67,8 +42,8 @@ int git_thread_create(
 	return thread->thread ? 0 : -1;
 }
 
-int git_thread_join(
-	git_thread *thread,
+int git_win32__thread_join(
+	git_win32_thread *thread,
 	void **value_ptr)
 {
 	DWORD exit;
@@ -95,32 +70,39 @@ int git_thread_join(
 	return 0;
 }
 
-int git_mutex_init(git_mutex *GIT_RESTRICT mutex)
+int pthread_mutex_init(
+	pthread_mutex_t *GIT_RESTRICT mutex,
+	const pthread_mutexattr_t *GIT_RESTRICT mutexattr)
 {
+	GIT_UNUSED(mutexattr);
 	InitializeCriticalSection(mutex);
 	return 0;
 }
 
-int git_mutex_free(git_mutex *mutex)
+int pthread_mutex_destroy(pthread_mutex_t *mutex)
 {
 	DeleteCriticalSection(mutex);
 	return 0;
 }
 
-int git_mutex_lock(git_mutex *mutex)
+int pthread_mutex_lock(pthread_mutex_t *mutex)
 {
 	EnterCriticalSection(mutex);
 	return 0;
 }
 
-int git_mutex_unlock(git_mutex *mutex)
+int pthread_mutex_unlock(pthread_mutex_t *mutex)
 {
 	LeaveCriticalSection(mutex);
 	return 0;
 }
 
-int git_cond_init(git_cond *cond)
+int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
 {
+	/* We don't support non-default attributes. */
+	if (attr)
+		return EINVAL;
+
 	/* This is an auto-reset event. */
 	*cond = CreateEventW(NULL, FALSE, FALSE, NULL);
 	assert(*cond);
@@ -130,7 +112,7 @@ int git_cond_init(git_cond *cond)
 	return *cond ? 0 : ENOMEM;
 }
 
-int git_cond_free(git_cond *cond)
+int pthread_cond_destroy(pthread_cond_t *cond)
 {
 	BOOL closed;
 
@@ -145,7 +127,7 @@ int git_cond_free(git_cond *cond)
 	return 0;
 }
 
-int git_cond_wait(git_cond *cond, git_mutex *mutex)
+int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 {
 	int error;
 	DWORD wait_result;
@@ -154,7 +136,7 @@ int git_cond_wait(git_cond *cond, git_mutex *mutex)
 		return EINVAL;
 
 	/* The caller must be holding the mutex. */
-	error = git_mutex_unlock(mutex);
+	error = pthread_mutex_unlock(mutex);
 
 	if (error)
 		return error;
@@ -163,10 +145,10 @@ int git_cond_wait(git_cond *cond, git_mutex *mutex)
 	assert(WAIT_OBJECT_0 == wait_result);
 	GIT_UNUSED(wait_result);
 
-	return git_mutex_lock(mutex);
+	return pthread_mutex_lock(mutex);
 }
 
-int git_cond_signal(git_cond *cond)
+int pthread_cond_signal(pthread_cond_t *cond)
 {
 	BOOL signaled;
 
@@ -180,8 +162,36 @@ int git_cond_signal(git_cond *cond)
 	return 0;
 }
 
-int git_rwlock_init(git_rwlock *GIT_RESTRICT lock)
+/* pthread_cond_broadcast is not implemented because doing so with just
+ * Win32 events is quite complicated, and no caller in libgit2 uses it
+ * yet.
+ */
+int pthread_num_processors_np(void)
+{
+	DWORD_PTR p, s;
+	int n = 0;
+
+	if (GetProcessAffinityMask(GetCurrentProcess(), &p, &s))
+		for (; p; p >>= 1)
+			n += p&1;
+
+	return n ? n : 1;
+}
+
+typedef void (WINAPI *win32_srwlock_fn)(GIT_SRWLOCK *);
+
+static win32_srwlock_fn win32_srwlock_initialize;
+static win32_srwlock_fn win32_srwlock_acquire_shared;
+static win32_srwlock_fn win32_srwlock_release_shared;
+static win32_srwlock_fn win32_srwlock_acquire_exclusive;
+static win32_srwlock_fn win32_srwlock_release_exclusive;
+
+int pthread_rwlock_init(
+	pthread_rwlock_t *GIT_RESTRICT lock,
+	const pthread_rwlockattr_t *GIT_RESTRICT attr)
 {
+	GIT_UNUSED(attr);
+
 	if (win32_srwlock_initialize)
 		win32_srwlock_initialize(&lock->native.srwl);
 	else
@@ -190,7 +200,7 @@ int git_rwlock_init(git_rwlock *GIT_RESTRICT lock)
 	return 0;
 }
 
-int git_rwlock_rdlock(git_rwlock *lock)
+int pthread_rwlock_rdlock(pthread_rwlock_t *lock)
 {
 	if (win32_srwlock_acquire_shared)
 		win32_srwlock_acquire_shared(&lock->native.srwl);
@@ -200,7 +210,7 @@ int git_rwlock_rdlock(git_rwlock *lock)
 	return 0;
 }
 
-int git_rwlock_rdunlock(git_rwlock *lock)
+int pthread_rwlock_rdunlock(pthread_rwlock_t *lock)
 {
 	if (win32_srwlock_release_shared)
 		win32_srwlock_release_shared(&lock->native.srwl);
@@ -210,7 +220,7 @@ int git_rwlock_rdunlock(git_rwlock *lock)
 	return 0;
 }
 
-int git_rwlock_wrlock(git_rwlock *lock)
+int pthread_rwlock_wrlock(pthread_rwlock_t *lock)
 {
 	if (win32_srwlock_acquire_exclusive)
 		win32_srwlock_acquire_exclusive(&lock->native.srwl);
@@ -220,7 +230,7 @@ int git_rwlock_wrlock(git_rwlock *lock)
 	return 0;
 }
 
-int git_rwlock_wrunlock(git_rwlock *lock)
+int pthread_rwlock_wrunlock(pthread_rwlock_t *lock)
 {
 	if (win32_srwlock_release_exclusive)
 		win32_srwlock_release_exclusive(&lock->native.srwl);
@@ -230,10 +240,30 @@ int git_rwlock_wrunlock(git_rwlock *lock)
 	return 0;
 }
 
-int git_rwlock_free(git_rwlock *lock)
+int pthread_rwlock_destroy(pthread_rwlock_t *lock)
 {
 	if (!win32_srwlock_initialize)
 		DeleteCriticalSection(&lock->native.csec);
 	git__memzero(lock, sizeof(*lock));
 	return 0;
 }
+
+int win32_pthread_initialize(void)
+{
+	HMODULE hModule = GetModuleHandleW(L"kernel32");
+
+	if (hModule) {
+		win32_srwlock_initialize = (win32_srwlock_fn)
+			GetProcAddress(hModule, "InitializeSRWLock");
+		win32_srwlock_acquire_shared = (win32_srwlock_fn)
+			GetProcAddress(hModule, "AcquireSRWLockShared");
+		win32_srwlock_release_shared = (win32_srwlock_fn)
+			GetProcAddress(hModule, "ReleaseSRWLockShared");
+		win32_srwlock_acquire_exclusive = (win32_srwlock_fn)
+			GetProcAddress(hModule, "AcquireSRWLockExclusive");
+		win32_srwlock_release_exclusive = (win32_srwlock_fn)
+			GetProcAddress(hModule, "ReleaseSRWLockExclusive");
+	}
+
+	return 0;
+}

data/vendor/libgit2/src/win32/pthread.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * 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 GIT_PTHREAD_H
+#define GIT_PTHREAD_H
+
+#include "../common.h"
+
+#if defined (_MSC_VER)
+#	define GIT_RESTRICT __restrict
+#else
+#	define GIT_RESTRICT __restrict__
+#endif
+
+typedef struct {
+	HANDLE thread;
+	void *(*proc)(void *);
+	void *param;
+	void *result;
+} git_win32_thread;
+
+typedef int pthread_mutexattr_t;
+typedef int pthread_condattr_t;
+typedef int pthread_attr_t;
+typedef int pthread_rwlockattr_t;
+
+typedef CRITICAL_SECTION pthread_mutex_t;
+typedef HANDLE pthread_cond_t;
+
+typedef struct { void *Ptr; } GIT_SRWLOCK;
+
+typedef struct {
+	union {
+		GIT_SRWLOCK srwl;
+		CRITICAL_SECTION csec;
+	} native;
+} pthread_rwlock_t;
+
+#define PTHREAD_MUTEX_INITIALIZER  {(void*)-1}
+
+int git_win32__thread_create(
+	git_win32_thread *GIT_RESTRICT,
+	const pthread_attr_t *GIT_RESTRICT,
+	void *(*) (void *),
+	void *GIT_RESTRICT);
+
+int git_win32__thread_join(
+	git_win32_thread *,
+	void **);
+
+#ifdef GIT_THREADS
+
+typedef git_win32_thread git_thread;
+
+#define git_thread_create(git_thread_ptr, attr, start_routine, arg) \
+	git_win32__thread_create(git_thread_ptr, attr, start_routine, arg)
+#define git_thread_join(git_thread_ptr, status) \
+	git_win32__thread_join(git_thread_ptr, status)
+
+#endif
+
+int pthread_mutex_init(
+	pthread_mutex_t *GIT_RESTRICT mutex,
+	const pthread_mutexattr_t *GIT_RESTRICT mutexattr);
+int pthread_mutex_destroy(pthread_mutex_t *);
+int pthread_mutex_lock(pthread_mutex_t *);
+int pthread_mutex_unlock(pthread_mutex_t *);
+
+int pthread_cond_init(pthread_cond_t *, const pthread_condattr_t *);
+int pthread_cond_destroy(pthread_cond_t *);
+int pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *);
+int pthread_cond_signal(pthread_cond_t *);
+/* pthread_cond_broadcast is not supported on Win32 yet. */
+
+int pthread_num_processors_np(void);
+
+int pthread_rwlock_init(
+	pthread_rwlock_t *GIT_RESTRICT lock,
+	const pthread_rwlockattr_t *GIT_RESTRICT attr);
+int pthread_rwlock_rdlock(pthread_rwlock_t *);
+int pthread_rwlock_rdunlock(pthread_rwlock_t *);
+int pthread_rwlock_wrlock(pthread_rwlock_t *);
+int pthread_rwlock_wrunlock(pthread_rwlock_t *);
+int pthread_rwlock_destroy(pthread_rwlock_t *);
+
+extern int win32_pthread_initialize(void);
+
+#endif