rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/config_entries.c

@@ -1,237 +0,0 @@
-/*
- * 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 "config_entries.h"
-
-typedef struct config_entry_list {
-	struct config_entry_list *next;
-	struct config_entry_list *last;
-	git_config_entry *entry;
-} config_entry_list;
-
-typedef struct {
-	git_config_entry *entry;
-	bool multivar;
-} config_entry_map_head;
-
-typedef struct config_entries_iterator {
-	git_config_iterator parent;
-	git_config_entries *entries;
-	config_entry_list *head;
-} config_entries_iterator;
-
-struct git_config_entries {
-	git_refcount rc;
-	git_strmap *map;
-	config_entry_list *list;
-};
-
-int git_config_entries_new(git_config_entries **out)
-{
-	git_config_entries *entries;
-	int error;
-
-	entries = git__calloc(1, sizeof(git_config_entries));
-	GIT_ERROR_CHECK_ALLOC(entries);
-	GIT_REFCOUNT_INC(entries);
-
-	if ((error = git_strmap_new(&entries->map)) < 0)
-		git__free(entries);
-	else
-		*out = entries;
-
-	return error;
-}
-
-int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry)
-{
-	git_config_entry *duplicated;
-	int error;
-
-	duplicated = git__calloc(1, sizeof(git_config_entry));
-	GIT_ERROR_CHECK_ALLOC(duplicated);
-
-	duplicated->name = git__strdup(entry->name);
-	GIT_ERROR_CHECK_ALLOC(duplicated->name);
-
-	if (entry->value) {
-		duplicated->value = git__strdup(entry->value);
-		GIT_ERROR_CHECK_ALLOC(duplicated->value);
-	}
-	duplicated->level = entry->level;
-	duplicated->include_depth = entry->include_depth;
-
-	if ((error = git_config_entries_append(entries, duplicated)) < 0)
-		goto out;
-
-out:
-	if (error && duplicated) {
-		git__free((char *) duplicated->name);
-		git__free((char *) duplicated->value);
-		git__free(duplicated);
-	}
-	return error;
-}
-
-int git_config_entries_dup(git_config_entries **out, git_config_entries *entries)
-{
-	git_config_entries *result = NULL;
-	config_entry_list *head;
-	int error;
-
-	if ((error = git_config_entries_new(&result)) < 0)
-		goto out;
-
-	for (head = entries->list; head; head = head->next)
-		if ((git_config_entries_dup_entry(result, head->entry)) < 0)
-			goto out;
-
-	*out = result;
-	result = NULL;
-
-out:
-	git_config_entries_free(result);
-	return error;
-}
-
-void git_config_entries_incref(git_config_entries *entries)
-{
-	GIT_REFCOUNT_INC(entries);
-}
-
-static void config_entries_free(git_config_entries *entries)
-{
-	config_entry_list *list = NULL, *next;
-	config_entry_map_head *head;
-
-	git_strmap_foreach_value(entries->map, head,
-		git__free((char *) head->entry->name); git__free(head)
-	);
-	git_strmap_free(entries->map);
-
-	list = entries->list;
-	while (list != NULL) {
-		next = list->next;
-		git__free((char *) list->entry->value);
-		git__free(list->entry);
-		git__free(list);
-		list = next;
-	}
-
-	git__free(entries);
-}
-
-void git_config_entries_free(git_config_entries *entries)
-{
-	if (entries)
-		GIT_REFCOUNT_DEC(entries, config_entries_free);
-}
-
-int git_config_entries_append(git_config_entries *entries, git_config_entry *entry)
-{
-	config_entry_list *list_head;
-	config_entry_map_head *map_head;
-
-	if ((map_head = git_strmap_get(entries->map, entry->name)) != NULL) {
-		map_head->multivar = true;
-		/*
-		 * This is a micro-optimization for configuration files
-		 * with a lot of same keys. As for multivars the entry's
-		 * key will be the same for all entries, we can just free
-		 * all except the first entry's name and just re-use it.
-		 */
-		git__free((char *) entry->name);
-		entry->name = map_head->entry->name;
-	} else {
-		map_head = git__calloc(1, sizeof(*map_head));
-		if ((git_strmap_set(entries->map, entry->name, map_head)) < 0)
-			return -1;
-	}
-	map_head->entry = entry;
-
-	list_head = git__calloc(1, sizeof(config_entry_list));
-	GIT_ERROR_CHECK_ALLOC(list_head);
-	list_head->entry = entry;
-
-	if (entries->list)
-		entries->list->last->next = list_head;
-	else
-		entries->list = list_head;
-	entries->list->last = list_head;
-
-	return 0;
-}
-
-int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key)
-{
-	config_entry_map_head *entry;
-	if ((entry = git_strmap_get(entries->map, key)) == NULL)
-		return GIT_ENOTFOUND;
-	*out = entry->entry;
-	return 0;
-}
-
-int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key)
-{
-	config_entry_map_head *entry;
-
-	if ((entry = git_strmap_get(entries->map, key)) == NULL)
-		return GIT_ENOTFOUND;
-
-	if (entry->multivar) {
-		git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being a multivar");
-		return -1;
-	}
-
-	if (entry->entry->include_depth) {
-		git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being included");
-		return -1;
-	}
-
-	*out = entry->entry;
-
-	return 0;
-}
-
-static void config_iterator_free(git_config_iterator *iter)
-{
-	config_entries_iterator *it = (config_entries_iterator *) iter;
-	git_config_entries_free(it->entries);
-	git__free(it);
-}
-
-static int config_iterator_next(
-	git_config_entry **entry,
-	git_config_iterator *iter)
-{
-	config_entries_iterator *it = (config_entries_iterator *) iter;
-
-	if (!it->head)
-		return GIT_ITEROVER;
-
-	*entry = it->head->entry;
-	it->head = it->head->next;
-
-	return 0;
-}
-
-int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries)
-{
-	config_entries_iterator *it;
-
-	it = git__calloc(1, sizeof(config_entries_iterator));
-	GIT_ERROR_CHECK_ALLOC(it);
-	it->parent.next = config_iterator_next;
-	it->parent.free = config_iterator_free;
-	it->head = entries->list;
-	it->entries = entries;
-
-	git_config_entries_incref(entries);
-	*out = &it->parent;
-
-	return 0;
-}

data/vendor/libgit2/src/config_entries.h

@@ -1,24 +0,0 @@
-/*
- * 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 "common.h"
-
-#include "git2/sys/config.h"
-#include "config.h"
-
-typedef struct git_config_entries git_config_entries;
-
-int git_config_entries_new(git_config_entries **out);
-int git_config_entries_dup(git_config_entries **out, git_config_entries *entries);
-int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry);
-void git_config_entries_incref(git_config_entries *entries);
-void git_config_entries_free(git_config_entries *entries);
-/* Add or append the new config option */
-int git_config_entries_append(git_config_entries *entries, git_config_entry *entry);
-int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key);
-int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key);
-int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries);

data/vendor/libgit2/src/config_mem.c

@@ -1,220 +0,0 @@
-/*
- * 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 "config.h"
-
-#include "config_backend.h"
-#include "config_parse.h"
-#include "config_entries.h"
-
-typedef struct {
-	git_config_backend parent;
-	git_config_entries *entries;
-	git_buf cfg;
-} config_memory_backend;
-
-typedef struct {
-	git_config_entries *entries;
-	git_config_level_t level;
-} config_memory_parse_data;
-
-static int config_error_readonly(void)
-{
-	git_error_set(GIT_ERROR_CONFIG, "this backend is read-only");
-	return -1;
-}
-
-static int read_variable_cb(
-	git_config_parser *reader,
-	const char *current_section,
-	const char *var_name,
-	const char *var_value,
-	const char *line,
-	size_t line_len,
-	void *payload)
-{
-	config_memory_parse_data *parse_data = (config_memory_parse_data *) payload;
-	git_buf buf = GIT_BUF_INIT;
-	git_config_entry *entry;
-	const char *c;
-	int result;
-
-	GIT_UNUSED(reader);
-	GIT_UNUSED(line);
-	GIT_UNUSED(line_len);
-
-	if (current_section) {
-		/* TODO: Once warnings land, we should likely warn
-		 * here. Git appears to warn in most cases if it sees
-		 * un-namespaced config options.
-		 */
-		git_buf_puts(&buf, current_section);
-		git_buf_putc(&buf, '.');
-	}
-
-	for (c = var_name; *c; c++)
-		git_buf_putc(&buf, git__tolower(*c));
-
-	if (git_buf_oom(&buf))
-		return -1;
-
-	entry = git__calloc(1, sizeof(git_config_entry));
-	GIT_ERROR_CHECK_ALLOC(entry);
-	entry->name = git_buf_detach(&buf);
-	entry->value = var_value ? git__strdup(var_value) : NULL;
-	entry->level = parse_data->level;
-	entry->include_depth = 0;
-
-	if ((result = git_config_entries_append(parse_data->entries, entry)) < 0)
-		return result;
-
-	return result;
-}
-
-static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo)
-{
-	config_memory_backend *memory_backend = (config_memory_backend *) backend;
-	git_config_parser parser = GIT_PARSE_CTX_INIT;
-	config_memory_parse_data parse_data;
-	int error;
-
-	GIT_UNUSED(repo);
-
-	if ((error = git_config_parser_init(&parser, "in-memory", memory_backend->cfg.ptr,
-					    memory_backend->cfg.size)) < 0)
-		goto out;
-	parse_data.entries = memory_backend->entries;
-	parse_data.level = level;
-
-	if ((error = git_config_parse(&parser, NULL, read_variable_cb, NULL, NULL, &parse_data)) < 0)
-		goto out;
-
-out:
-	git_config_parser_dispose(&parser);
-	return error;
-}
-
-static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out)
-{
-	config_memory_backend *memory_backend = (config_memory_backend *) backend;
-	return git_config_entries_get(out, memory_backend->entries, key);
-}
-
-static int config_memory_iterator(
-	git_config_iterator **iter,
-	git_config_backend *backend)
-{
-	config_memory_backend *memory_backend = (config_memory_backend *) backend;
-	git_config_entries *entries;
-	int error;
-
-	if ((error = git_config_entries_dup(&entries, memory_backend->entries)) < 0)
-		goto out;
-
-	if ((error = git_config_entries_iterator_new(iter, entries)) < 0)
-		goto out;
-
-out:
-	/* Let iterator delete duplicated entries when it's done */
-	git_config_entries_free(entries);
-	return error;
-}
-
-static int config_memory_set(git_config_backend *backend, const char *name, const char *value)
-{
-	GIT_UNUSED(backend);
-	GIT_UNUSED(name);
-	GIT_UNUSED(value);
-	return config_error_readonly();
-}
-
-static int config_memory_set_multivar(
-	git_config_backend *backend, const char *name, const char *regexp, const char *value)
-{
-	GIT_UNUSED(backend);
-	GIT_UNUSED(name);
-	GIT_UNUSED(regexp);
-	GIT_UNUSED(value);
-	return config_error_readonly();
-}
-
-static int config_memory_delete(git_config_backend *backend, const char *name)
-{
-	GIT_UNUSED(backend);
-	GIT_UNUSED(name);
-	return config_error_readonly();
-}
-
-static int config_memory_delete_multivar(git_config_backend *backend, const char *name, const char *regexp)
-{
-	GIT_UNUSED(backend);
-	GIT_UNUSED(name);
-	GIT_UNUSED(regexp);
-	return config_error_readonly();
-}
-
-static int config_memory_lock(git_config_backend *backend)
-{
-	GIT_UNUSED(backend);
-	return config_error_readonly();
-}
-
-static int config_memory_unlock(git_config_backend *backend, int success)
-{
-	GIT_UNUSED(backend);
-	GIT_UNUSED(success);
-	return config_error_readonly();
-}
-
-static void config_memory_free(git_config_backend *_backend)
-{
-	config_memory_backend *backend = (config_memory_backend *)_backend;
-
-	if (backend == NULL)
-		return;
-
-	git_config_entries_free(backend->entries);
-	git_buf_dispose(&backend->cfg);
-	git__free(backend);
-}
-
-int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len)
-{
-	config_memory_backend *backend;
-
-	backend = git__calloc(1, sizeof(config_memory_backend));
-	GIT_ERROR_CHECK_ALLOC(backend);
-
-	if (git_config_entries_new(&backend->entries) < 0) {
-		git__free(backend);
-		return -1;
-	}
-
-	if (git_buf_set(&backend->cfg, cfg, len) < 0) {
-		git_config_entries_free(backend->entries);
-		git__free(backend);
-		return -1;
-	}
-
-	backend->parent.version = GIT_CONFIG_BACKEND_VERSION;
-	backend->parent.readonly = 1;
-	backend->parent.open = config_memory_open;
-	backend->parent.get = config_memory_get;
-	backend->parent.set = config_memory_set;
-	backend->parent.set_multivar = config_memory_set_multivar;
-	backend->parent.del = config_memory_delete;
-	backend->parent.del_multivar = config_memory_delete_multivar;
-	backend->parent.iterator = config_memory_iterator;
-	backend->parent.lock = config_memory_lock;
-	backend->parent.unlock = config_memory_unlock;
-	backend->parent.snapshot = git_config_backend_snapshot;
-	backend->parent.free = config_memory_free;
-
-	*out = (git_config_backend *)backend;
-
-	return 0;
-}

data/vendor/libgit2/src/errors.c

@@ -1,238 +0,0 @@
-/*
- * 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 "common.h"
-
-#include "threadstate.h"
-#include "posix.h"
-#include "buffer.h"
-#include "libgit2.h"
-
-/********************************************
- * New error handling
- ********************************************/
-
-static git_error g_git_oom_error = {
-	"Out of memory",
-	GIT_ERROR_NOMEMORY
-};
-
-static git_error g_git_uninitialized_error = {
-	"libgit2 has not been initialized; you must call git_libgit2_init",
-	GIT_ERROR_INVALID
-};
-
-static void set_error_from_buffer(int error_class)
-{
-	git_error *error = &GIT_THREADSTATE->error_t;
-	git_buf *buf = &GIT_THREADSTATE->error_buf;
-
-	error->message = buf->ptr;
-	error->klass = error_class;
-
-	GIT_THREADSTATE->last_error = error;
-}
-
-static void set_error(int error_class, char *string)
-{
-	git_buf *buf = &GIT_THREADSTATE->error_buf;
-
-	git_buf_clear(buf);
-	if (string) {
-		git_buf_puts(buf, string);
-		git__free(string);
-	}
-
-	set_error_from_buffer(error_class);
-}
-
-void git_error_set_oom(void)
-{
-	GIT_THREADSTATE->last_error = &g_git_oom_error;
-}
-
-void git_error_set(int error_class, const char *fmt, ...)
-{
-	va_list ap;
-
-	va_start(ap, fmt);
-	git_error_vset(error_class, fmt, ap);
-	va_end(ap);
-}
-
-void git_error_vset(int error_class, const char *fmt, va_list ap)
-{
-#ifdef GIT_WIN32
-	DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0;
-#endif
-	int error_code = (error_class == GIT_ERROR_OS) ? errno : 0;
-	git_buf *buf = &GIT_THREADSTATE->error_buf;
-
-	git_buf_clear(buf);
-	if (fmt) {
-		git_buf_vprintf(buf, fmt, ap);
-		if (error_class == GIT_ERROR_OS)
-			git_buf_PUTS(buf, ": ");
-	}
-
-	if (error_class == GIT_ERROR_OS) {
-#ifdef GIT_WIN32
-		char * win32_error = git_win32_get_error_message(win32_error_code);
-		if (win32_error) {
-			git_buf_puts(buf, win32_error);
-			git__free(win32_error);
-
-			SetLastError(0);
-		}
-		else
-#endif
-		if (error_code)
-			git_buf_puts(buf, strerror(error_code));
-
-		if (error_code)
-			errno = 0;
-	}
-
-	if (!git_buf_oom(buf))
-		set_error_from_buffer(error_class);
-}
-
-int git_error_set_str(int error_class, const char *string)
-{
-	git_buf *buf = &GIT_THREADSTATE->error_buf;
-
-	GIT_ASSERT_ARG(string);
-
-	git_buf_clear(buf);
-	git_buf_puts(buf, string);
-
-	if (git_buf_oom(buf))
-		return -1;
-
-	set_error_from_buffer(error_class);
-	return 0;
-}
-
-void git_error_clear(void)
-{
-	if (GIT_THREADSTATE->last_error != NULL) {
-		set_error(0, NULL);
-		GIT_THREADSTATE->last_error = NULL;
-	}
-
-	errno = 0;
-#ifdef GIT_WIN32
-	SetLastError(0);
-#endif
-}
-
-const git_error *git_error_last(void)
-{
-	/* If the library is not initialized, return a static error. */
-	if (!git_libgit2_init_count())
-		return &g_git_uninitialized_error;
-
-	return GIT_THREADSTATE->last_error;
-}
-
-int git_error_state_capture(git_error_state *state, int error_code)
-{
-	git_error *error = GIT_THREADSTATE->last_error;
-	git_buf *error_buf = &GIT_THREADSTATE->error_buf;
-
-	memset(state, 0, sizeof(git_error_state));
-
-	if (!error_code)
-		return 0;
-
-	state->error_code = error_code;
-	state->oom = (error == &g_git_oom_error);
-
-	if (error) {
-		state->error_msg.klass = error->klass;
-
-		if (state->oom)
-			state->error_msg.message = g_git_oom_error.message;
-		else
-			state->error_msg.message = git_buf_detach(error_buf);
-	}
-
-	git_error_clear();
-	return error_code;
-}
-
-int git_error_state_restore(git_error_state *state)
-{
-	int ret = 0;
-
-	git_error_clear();
-
-	if (state && state->error_msg.message) {
-		if (state->oom)
-			git_error_set_oom();
-		else
-			set_error(state->error_msg.klass, state->error_msg.message);
-
-		ret = state->error_code;
-		memset(state, 0, sizeof(git_error_state));
-	}
-
-	return ret;
-}
-
-void git_error_state_free(git_error_state *state)
-{
-	if (!state)
-		return;
-
-	if (!state->oom)
-		git__free(state->error_msg.message);
-
-	memset(state, 0, sizeof(git_error_state));
-}
-
-int git_error_system_last(void)
-{
-#ifdef GIT_WIN32
-	return GetLastError();
-#else
-	return errno;
-#endif
-}
-
-void git_error_system_set(int code)
-{
-#ifdef GIT_WIN32
-	SetLastError(code);
-#else
-	errno = code;
-#endif
-}
-
-/* Deprecated error values and functions */
-
-#ifndef GIT_DEPRECATE_HARD
-const git_error *giterr_last(void)
-{
-	return git_error_last();
-}
-
-void giterr_clear(void)
-{
-	git_error_clear();
-}
-
-void giterr_set_str(int error_class, const char *string)
-{
-	git_error_set_str(error_class, string);
-}
-
-void giterr_set_oom(void)
-{
-	git_error_set_oom();
-}
-#endif