rugged 0.19.0 → 0.28.0

data/vendor/libgit2/src/pathspec.h

@@ -8,9 +8,36 @@
 #define INCLUDE_pathspec_h__
 
 #include "common.h"
+
+#include "git2/pathspec.h"
 #include "buffer.h"
 #include "vector.h"
 #include "pool.h"
+#include "array.h"
+
+/* public compiled pathspec */
+struct git_pathspec {
+	git_refcount rc;
+	char *prefix;
+	git_vector pathspec;
+	git_pool pool;
+};
+
+enum {
+	PATHSPEC_DATATYPE_STRINGS = 0,
+	PATHSPEC_DATATYPE_DIFF = 1,
+};
+
+typedef git_array_t(char *) git_pathspec_string_array_t;
+
+/* public interface to pathspec matching */
+struct git_pathspec_match_list {
+	git_pathspec *pathspec;
+	git_array_t(void *) matches;
+	git_pathspec_string_array_t failures;
+	git_pool pool;
+	int datatype;
+};
 
 /* what is the common non-wildcard prefix for all items in the pathspec */
 extern char *git_pathspec_prefix(const git_strarray *pathspec);
@@ -19,36 +46,31 @@ extern char *git_pathspec_prefix(const git_strarray *pathspec);
 extern bool git_pathspec_is_empty(const git_strarray *pathspec);
 
 /* build a vector of fnmatch patterns to evaluate efficiently */
-extern int git_pathspec_init(
+extern int git_pathspec__vinit(
 	git_vector *vspec, const git_strarray *strspec, git_pool *strpool);
 
 /* free data from the pathspec vector */
-extern void git_pathspec_free(git_vector *vspec);
+extern void git_pathspec__vfree(git_vector *vspec);
+
+#define GIT_PATHSPEC_NOMATCH ((size_t)-1)
 
 /*
  * Match a path against the vectorized pathspec.
  * The matched pathspec is passed back into the `matched_pathspec` parameter,
  * unless it is passed as NULL by the caller.
  */
-extern bool git_pathspec_match_path(
-	git_vector *vspec,
+extern bool git_pathspec__match(
+	const git_vector *vspec,
 	const char *path,
 	bool disable_fnmatch,
 	bool casefold,
-	const char **matched_pathspec);
+	const char **matched_pathspec,
+	size_t *matched_at);
 
 /* easy pathspec setup */
 
-typedef struct {
-	char *prefix;
-	git_vector pathspec;
-	git_pool pool;
-} git_pathspec_context;
-
-extern int git_pathspec_context_init(
-	git_pathspec_context *ctxt, const git_strarray *paths);
+extern int git_pathspec__init(git_pathspec *ps, const git_strarray *paths);
 
-extern void git_pathspec_context_free(
-	git_pathspec_context *ctxt);
+extern void git_pathspec__clear(git_pathspec *ps);
 
 #endif

data/vendor/libgit2/src/pool.c

@@ -1,4 +1,13 @@
+/*
+ * 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.
+ */
+
 #include "pool.h"
+
+#include "posix.h"
 #ifndef GIT_WIN32
 #include <unistd.h>
 #endif
@@ -7,203 +16,198 @@ struct git_pool_page {
 	git_pool_page *next;
 	uint32_t size;
 	uint32_t avail;
-	char data[GIT_FLEX_ARRAY];
+	GIT_ALIGN(char data[GIT_FLEX_ARRAY], 8);
 };
 
-struct pool_freelist {
-	struct pool_freelist *next;
-};
-
-#define GIT_POOL_MIN_USABLE	4
-#define GIT_POOL_MIN_PAGESZ	2 * sizeof(void*)
-
 static void *pool_alloc_page(git_pool *pool, uint32_t size);
-static void pool_insert_page(git_pool *pool, git_pool_page *page);
 
-int git_pool_init(
-	git_pool *pool, uint32_t item_size, uint32_t items_per_page)
+uint32_t git_pool__system_page_size(void)
 {
-	assert(pool);
+	static uint32_t size = 0;
+
+	if (!size) {
+		size_t page_size;
+		if (git__page_size(&page_size) < 0)
+			page_size = 4096;
+		/* allow space for malloc overhead */
+		size = page_size - (2 * sizeof(void *)) - sizeof(git_pool_page);
+	}
 
-	if (!item_size)
-		item_size = 1;
-	/* round up item_size for decent object alignment */
-	if (item_size > 4)
-		item_size = (item_size + 7) & ~7;
-	else if (item_size == 3)
-		item_size = 4;
+	return size;
+}
 
-	if (!items_per_page)
-		items_per_page = git_pool__suggest_items_per_page(item_size);
-	if (item_size * items_per_page < GIT_POOL_MIN_PAGESZ)
-		items_per_page = (GIT_POOL_MIN_PAGESZ + item_size - 1) / item_size;
+#ifndef GIT_DEBUG_POOL
+void git_pool_init(git_pool *pool, uint32_t item_size)
+{
+	assert(pool);
+	assert(item_size >= 1);
 
 	memset(pool, 0, sizeof(git_pool));
 	pool->item_size = item_size;
-	pool->page_size = item_size * items_per_page;
-
-	return 0;
+	pool->page_size = git_pool__system_page_size();
 }
 
 void git_pool_clear(git_pool *pool)
 {
 	git_pool_page *scan, *next;
 
-	for (scan = pool->open; scan != NULL; scan = next) {
+	for (scan = pool->pages; scan != NULL; scan = next) {
 		next = scan->next;
 		git__free(scan);
 	}
-	pool->open = NULL;
 
-	for (scan = pool->full; scan != NULL; scan = next) {
-		next = scan->next;
-		git__free(scan);
-	}
-	pool->full = NULL;
+	pool->pages = NULL;
+}
 
-	pool->free_list = NULL;
+static void *pool_alloc_page(git_pool *pool, uint32_t size)
+{
+	git_pool_page *page;
+	const uint32_t new_page_size = (size <= pool->page_size) ? pool->page_size : size;
+	size_t alloc_size;
+
+	if (GIT_ADD_SIZET_OVERFLOW(&alloc_size, new_page_size, sizeof(git_pool_page)) ||
+		!(page = git__malloc(alloc_size)))
+		return NULL;
 
-	pool->items = 0;
+	page->size = new_page_size;
+	page->avail = new_page_size - size;
+	page->next = pool->pages;
 
-	pool->has_string_alloc     = 0;
-	pool->has_multi_item_alloc = 0;
-	pool->has_large_page_alloc = 0;
+	pool->pages = page;
+
+	return page->data;
 }
 
-void git_pool_swap(git_pool *a, git_pool *b)
+static void *pool_alloc(git_pool *pool, uint32_t size)
 {
-	git_pool temp;
+	git_pool_page *page = pool->pages;
+	void *ptr = NULL;
 
-	if (a == b)
-		return;
+	if (!page || page->avail < size)
+		return pool_alloc_page(pool, size);
 
-	memcpy(&temp, a, sizeof(temp));
-	memcpy(a, b, sizeof(temp));
-	memcpy(b, &temp, sizeof(temp));
+	ptr = &page->data[page->size - page->avail];
+	page->avail -= size;
+
+	return ptr;
 }
 
-static void pool_insert_page(git_pool *pool, git_pool_page *page)
+uint32_t git_pool__open_pages(git_pool *pool)
 {
+	uint32_t ct = 0;
 	git_pool_page *scan;
-
-	/* If there are no open pages or this page has the most open space,
-	 * insert it at the beginning of the list.  This is the common case.
-	 */
-	if (pool->open == NULL || pool->open->avail < page->avail) {
-		page->next = pool->open;
-		pool->open = page;
-		return;
-	}
-
-	/* Otherwise insert into sorted position. */
-	for (scan = pool->open;
-		 scan->next && scan->next->avail > page->avail;
-		 scan = scan->next);
-	page->next = scan->next;
-	scan->next = page;
+	for (scan = pool->pages; scan != NULL; scan = scan->next) ct++;
+	return ct;
 }
 
-static void *pool_alloc_page(git_pool *pool, uint32_t size)
+bool git_pool__ptr_in_pool(git_pool *pool, void *ptr)
 {
-	git_pool_page *page;
-	uint32_t alloc_size;
-
-	if (size <= pool->page_size)
-		alloc_size = pool->page_size;
-	else {
-		alloc_size = size;
-		pool->has_large_page_alloc = 1;
-	}
-
-	page = git__calloc(1, alloc_size + sizeof(git_pool_page));
-	if (!page)
-		return NULL;
+	git_pool_page *scan;
+	for (scan = pool->pages; scan != NULL; scan = scan->next)
+		if ((void *)scan->data <= ptr &&
+			(void *)(((char *)scan->data) + scan->size) > ptr)
+			return true;
+	return false;
+}
 
-	page->size  = alloc_size;
-	page->avail = alloc_size - size;
+#else
 
-	if (page->avail > 0)
-		pool_insert_page(pool, page);
+static int git_pool__ptr_cmp(const void * a, const void * b)
+{
+	if(a > b) {
+		return 1;
+	}
+	if(a < b) {
+		return -1;
+	}
 	else {
-		page->next = pool->full;
-		pool->full = page;
+		return 0;
 	}
+}
 
-	pool->items++;
+void git_pool_init(git_pool *pool, uint32_t item_size)
+{
+	assert(pool);
+	assert(item_size >= 1);
 
-	return page->data;
+	memset(pool, 0, sizeof(git_pool));
+	pool->item_size = item_size;
+	pool->page_size = git_pool__system_page_size();
+	git_vector_init(&pool->allocations, 100, git_pool__ptr_cmp);
 }
 
-GIT_INLINE(void) pool_remove_page(
-	git_pool *pool, git_pool_page *page, git_pool_page *prev)
+void git_pool_clear(git_pool *pool)
 {
-	if (prev == NULL)
-		pool->open = page->next;
-	else
-		prev->next = page->next;
+	git_vector_free_deep(&pool->allocations);
 }
 
-void *git_pool_malloc(git_pool *pool, uint32_t items)
-{
-	git_pool_page *scan = pool->open, *prev;
-	uint32_t size = items * pool->item_size;
+static void *pool_alloc(git_pool *pool, uint32_t size) {
 	void *ptr = NULL;
-
-	pool->has_string_alloc = 0;
-	if (items > 1)
-		pool->has_multi_item_alloc = 1;
-	else if (pool->free_list != NULL) {
-		ptr = pool->free_list;
-		pool->free_list = ((struct pool_freelist *)pool->free_list)->next;
-		return ptr;
+	if((ptr = git__malloc(size)) == NULL) {
+		return NULL;
 	}
+	git_vector_insert_sorted(&pool->allocations, ptr, NULL);
+	return ptr;
+}
 
-	/* just add a block if there is no open one to accomodate this */
-	if (size >= pool->page_size || !scan || scan->avail < size)
-		return pool_alloc_page(pool, size);
+bool git_pool__ptr_in_pool(git_pool *pool, void *ptr)
+{
+	size_t pos;
+	return git_vector_bsearch(&pos, &pool->allocations, ptr) != GIT_ENOTFOUND;
+}
+#endif
+
+void git_pool_swap(git_pool *a, git_pool *b)
+{
+	git_pool temp;
 
-	pool->items++;
+	if (a == b)
+		return;
 
-	/* find smallest block in free list with space */
-	for (scan = pool->open, prev = NULL;
-		 scan->next && scan->next->avail >= size;
-		 prev = scan, scan = scan->next);
+	memcpy(&temp, a, sizeof(temp));
+	memcpy(a, b, sizeof(temp));
+	memcpy(b, &temp, sizeof(temp));
+}
 
-	/* allocate space from the block */
-	ptr = &scan->data[scan->size - scan->avail];
-	scan->avail -= size;
+static uint32_t alloc_size(git_pool *pool, uint32_t count)
+{
+	const uint32_t align = sizeof(void *) - 1;
 
-	/* move to full list if there is almost no space left */
-	if (scan->avail < pool->item_size || scan->avail < GIT_POOL_MIN_USABLE) {
-		pool_remove_page(pool, scan, prev);
-		scan->next = pool->full;
-		pool->full = scan;
-	}
-	/* reorder list if block is now smaller than the one after it */
-	else if (scan->next != NULL && scan->next->avail > scan->avail) {
-		pool_remove_page(pool, scan, prev);
-		pool_insert_page(pool, scan);
+	if (pool->item_size > 1) {
+		const uint32_t item_size = (pool->item_size + align) & ~align;
+		return item_size * count;
 	}
 
+	return (count + align) & ~align;
+}
+
+void *git_pool_malloc(git_pool *pool, uint32_t items)
+{
+	return pool_alloc(pool, alloc_size(pool, items));
+}
+
+void *git_pool_mallocz(git_pool *pool, uint32_t items)
+{
+	const uint32_t size = alloc_size(pool, items);
+	void *ptr = pool_alloc(pool, size);
+	if (ptr)
+		memset(ptr, 0x0, size);
 	return ptr;
 }
 
 char *git_pool_strndup(git_pool *pool, const char *str, size_t n)
 {
-	void *ptr = NULL;
+	char *ptr = NULL;
 
 	assert(pool && str && pool->item_size == sizeof(char));
 
-	if (n + 1 == 0) {
-		giterr_set_oom();
+	if ((uint32_t)(n + 1) < n)
 		return NULL;
-	}
 
 	if ((ptr = git_pool_malloc(pool, (uint32_t)(n + 1))) != NULL) {
 		memcpy(ptr, str, n);
-		*(((char *)ptr) + n) = '\0';
+		ptr[n] = '\0';
 	}
-	pool->has_string_alloc = 1;
 
 	return ptr;
 }
@@ -211,7 +215,6 @@ char *git_pool_strndup(git_pool *pool, const char *str, size_t n)
 char *git_pool_strdup(git_pool *pool, const char *str)
 {
 	assert(pool && str && pool->item_size == sizeof(char));
-
 	return git_pool_strndup(pool, str, strlen(str));
 }
 
@@ -225,7 +228,7 @@ char *git_pool_strcat(git_pool *pool, const char *a, const char *b)
 	void *ptr;
 	size_t len_a, len_b;
 
-	assert(pool && a && b && pool->item_size == sizeof(char));
+	assert(pool && pool->item_size == sizeof(char));
 
 	len_a = a ? strlen(a) : 0;
 	len_b = b ? strlen(b) : 0;
@@ -237,95 +240,5 @@ char *git_pool_strcat(git_pool *pool, const char *a, const char *b)
 			memcpy(((char *)ptr) + len_a, b, len_b);
 		*(((char *)ptr) + len_a + len_b) = '\0';
 	}
-	pool->has_string_alloc = 1;
-
 	return ptr;
 }
-
-void git_pool_free(git_pool *pool, void *ptr)
-{
-	struct pool_freelist *item = ptr;
-
-	assert(pool && pool->item_size >= sizeof(void*));
-
-	if (item) {
-		item->next = pool->free_list;
-		pool->free_list = item;
-	}
-}
-
-void git_pool_free_array(git_pool *pool, size_t count, void **ptrs)
-{
-	struct pool_freelist **items = (struct pool_freelist **)ptrs;
-	size_t i;
-
-	assert(pool && ptrs && pool->item_size >= sizeof(void*));
-
-	if (!count)
-		return;
-
-	for (i = count - 1; i > 0; --i)
-		items[i]->next = items[i - 1];
-
-	items[i]->next  = pool->free_list;
-	pool->free_list = items[count - 1];
-}
-
-uint32_t git_pool__open_pages(git_pool *pool)
-{
-	uint32_t ct = 0;
-	git_pool_page *scan;
-	for (scan = pool->open; scan != NULL; scan = scan->next) ct++;
-	return ct;
-}
-
-uint32_t git_pool__full_pages(git_pool *pool)
-{
-	uint32_t ct = 0;
-	git_pool_page *scan;
-	for (scan = pool->full; scan != NULL; scan = scan->next) ct++;
-	return ct;
-}
-
-bool git_pool__ptr_in_pool(git_pool *pool, void *ptr)
-{
-	git_pool_page *scan;
-	for (scan = pool->open; scan != NULL; scan = scan->next)
-		if ((void *)scan->data <= ptr &&
-			(void *)(((char *)scan->data) + scan->size) > ptr)
-			return true;
-	for (scan = pool->full; scan != NULL; scan = scan->next)
-		if ((void *)scan->data <= ptr &&
-			(void *)(((char *)scan->data) + scan->size) > ptr)
-			return true;
-	return false;
-}
-
-uint32_t git_pool__system_page_size(void)
-{
-	static uint32_t size = 0;
-
-	if (!size) {
-#ifdef GIT_WIN32
-		SYSTEM_INFO info;
-		GetSystemInfo(&info);
-		size = (uint32_t)info.dwPageSize;
-#elif defined(__amigaos4__)
-		size = (uint32_t)4096; /* 4K as there is no global value we can query */
-#else
-		size = (uint32_t)sysconf(_SC_PAGE_SIZE);
-#endif
-
-		size -= 2 * sizeof(void *); /* allow space for malloc overhead */
-	}
-
-	return size;
-}
-
-uint32_t git_pool__suggest_items_per_page(uint32_t item_size)
-{
-	uint32_t page_bytes =
-		git_pool__system_page_size() - sizeof(git_pool_page);
-	return page_bytes / item_size;
-}
-

data/vendor/libgit2/src/pool.h

@@ -9,8 +9,11 @@
 
 #include "common.h"
 
+#include "vector.h"
+
 typedef struct git_pool_page git_pool_page;
 
+#ifndef GIT_DEBUG_POOL
 /**
  * Chunked allocator.
  *
@@ -28,37 +31,57 @@ typedef struct git_pool_page git_pool_page;
  * For examples of how to set up a `git_pool` see `git_pool_init`.
  */
 typedef struct {
-	git_pool_page *open; /* pages with space left */
-	git_pool_page *full; /* pages with no space left */
-	void *free_list;     /* optional: list of freed blocks */
+	git_pool_page *pages; /* allocated pages */
 	uint32_t item_size;  /* size of single alloc unit in bytes */
 	uint32_t page_size;  /* size of page in bytes */
-	uint32_t items;
-	unsigned has_string_alloc : 1; /* was the strdup function used */
-	unsigned has_multi_item_alloc : 1; /* was items ever > 1 in malloc */
-	unsigned has_large_page_alloc : 1; /* are any pages > page_size */
 } git_pool;
 
-#define GIT_POOL_INIT_STRINGPOOL { 0, 0, 0, 1, 4000, 0, 0, 0, 0 }
+#define GIT_POOL_INIT { NULL, 0, 0 }
+
+#else
+
+/**
+ * Debug chunked allocator.
+ *
+ * Acts just like `git_pool` but instead of actually pooling allocations it
+ * passes them through to `git__malloc`. This makes it possible to easily debug
+ * systems that use `git_pool` using valgrind.
+ *
+ * In order to track allocations during the lifetime of the pool we use a
+ * `git_vector`. When the pool is deallocated everything in the vector is
+ * freed.
+ *
+ * `API is exactly the same as the standard `git_pool` with one exception.
+ * Since we aren't allocating pages to hand out in chunks we can't easily
+ * implement `git_pool__open_pages`.
+ */
+typedef struct {
+	git_vector allocations;
+	uint32_t item_size;
+	uint32_t page_size;
+} git_pool;
+
+#define GIT_POOL_INIT { GIT_VECTOR_INIT, 0, 0 }
+
+#endif
 
 /**
  * Initialize a pool.
  *
  * To allocation strings, use like this:
  *
- *     git_pool_init(&string_pool, 1, 0);
+ *     git_pool_init(&string_pool, 1);
  *     my_string = git_pool_strdup(&string_pool, your_string);
  *
  * To allocate items of fixed size, use like this:
  *
- *     git_pool_init(&pool, sizeof(item), 0);
+ *     git_pool_init(&pool, sizeof(item));
  *     my_item = git_pool_malloc(&pool, 1);
  *
  * Of course, you can use this in other ways, but those are the
  * two most common patterns.
  */
-extern int git_pool_init(
-	git_pool *pool, uint32_t item_size, uint32_t items_per_page);
+extern void git_pool_init(git_pool *pool, uint32_t item_size);
 
 /**
  * Free all items in pool
@@ -74,17 +97,7 @@ extern void git_pool_swap(git_pool *a, git_pool *b);
  * Allocate space for one or more items from a pool.
  */
 extern void *git_pool_malloc(git_pool *pool, uint32_t items);
-
-/**
- * Allocate space and zero it out.
- */
-GIT_INLINE(void *) git_pool_mallocz(git_pool *pool, uint32_t items)
-{
-	void *ptr = git_pool_malloc(pool, items);
-	if (ptr)
-		memset(ptr, 0, (size_t)items * (size_t)pool->item_size);
-	return ptr;
-}
+extern void *git_pool_mallocz(git_pool *pool, uint32_t items);
 
 /**
  * Allocate space and duplicate string data into it.
@@ -114,37 +127,12 @@ extern char *git_pool_strdup_safe(git_pool *pool, const char *str);
  */
 extern char *git_pool_strcat(git_pool *pool, const char *a, const char *b);
 
-/**
- * Push a block back onto the free list for the pool.
- *
- * This is allowed only if the item_size is >= sizeof(void*).
- *
- * In some cases, it is helpful to "release" an allocated block
- * for reuse.  Pools don't support a general purpose free, but
- * they will keep a simple free blocks linked list provided the
- * native block size is large enough to hold a void pointer
- */
-extern void git_pool_free(git_pool *pool, void *ptr);
-
-/**
- * Push an array of pool allocated blocks efficiently onto the free list.
- *
- * This has the same constraints as `git_pool_free()` above.
- */
-extern void git_pool_free_array(git_pool *pool, size_t count, void **ptrs);
-
 /*
  * Misc utilities
  */
-
+#ifndef GIT_DEBUG_POOL
 extern uint32_t git_pool__open_pages(git_pool *pool);
-
-extern uint32_t git_pool__full_pages(git_pool *pool);
-
+#endif
 extern bool git_pool__ptr_in_pool(git_pool *pool, void *ptr);
 
-extern uint32_t git_pool__system_page_size(void);
-
-extern uint32_t git_pool__suggest_items_per_page(uint32_t item_size);
-
 #endif