rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/util/ctype_compat.h

@@ -0,0 +1,70 @@
+/*
+ * 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 INCLUDE_ctype_compat_h__
+#define INCLUDE_ctype_compat_h__
+
+/*
+ * The Microsoft C runtime (MSVCRT) may take a heavy lock on the
+ * locale in order to figure out how the `ctype` functions work.
+ * This is deeply slow. Provide our own to avoid that.
+ */
+
+#ifdef GIT_WIN32
+
+GIT_INLINE(int) git__tolower(int c)
+{
+	return (c >= 'A' && c <= 'Z') ? (c + 32) : c;
+}
+
+GIT_INLINE(int) git__toupper(int c)
+{
+	return (c >= 'a' && c <= 'z') ? (c - 32) : c;
+}
+
+GIT_INLINE(bool) git__isalpha(int c)
+{
+	return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
+}
+
+GIT_INLINE(bool) git__isdigit(int c)
+{
+	return (c >= '0' && c <= '9');
+}
+
+GIT_INLINE(bool) git__isalnum(int c)
+{
+	return git__isalpha(c) || git__isdigit(c);
+}
+
+GIT_INLINE(bool) git__isspace(int c)
+{
+	return (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r' || c == '\v');
+}
+
+GIT_INLINE(bool) git__isxdigit(int c)
+{
+	return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
+}
+
+GIT_INLINE(bool) git__isprint(int c)
+{
+	return (c >= ' ' && c <= '~');
+}
+
+#else
+# define git__tolower(a) tolower((unsigned char)(a))
+# define git__toupper(a) toupper((unsigned char)(a))
+
+# define git__isalpha(a)  (!!isalpha((unsigned char)(a)))
+# define git__isdigit(a)  (!!isdigit((unsigned char)(a)))
+# define git__isalnum(a)  (!!isalnum((unsigned char)(a)))
+# define git__isspace(a)  (!!isspace((unsigned char)(a)))
+# define git__isxdigit(a) (!!isxdigit((unsigned char)(a)))
+# define git__isprint(a)  (!!isprint((unsigned char)(a)))
+#endif
+
+#endif

data/vendor/libgit2/src/{date.c → util/date.c}

@@ -1,18 +1,19 @@
 /*
- * GIT - The information manager from hell
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
- * Copyright (C) Linus Torvalds, 2005
+ * 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_util.h"
 
 #ifndef GIT_WIN32
 #include <sys/time.h>
 #endif
 
 #include "util.h"
-#include "cache.h"
 #include "posix.h"
+#include "date.h"
 
 #include <ctype.h>
 #include <time.h>
@@ -128,9 +129,9 @@ static size_t match_string(const char *date, const char *str)
 	for (i = 0; *date; date++, str++, i++) {
 		if (*date == *str)
 			continue;
-		if (toupper(*date) == toupper(*str))
+		if (git__toupper(*date) == git__toupper(*str))
 			continue;
-		if (!isalnum(*date))
+		if (!git__isalnum(*date))
 			break;
 		return 0;
 	}
@@ -142,7 +143,7 @@ static int skip_alpha(const char *date)
 	int i = 0;
 	do {
 		i++;
-	} while (isalpha(date[i]));
+	} while (git__isalpha(date[i]));
 	return i;
 }
 
@@ -250,7 +251,7 @@ static size_t match_multi_number(unsigned long num, char c, const char *date, ch
 
 	num2 = strtol(end+1, &end, 10);
 	num3 = -1;
-	if (*end == c && isdigit(end[1]))
+	if (*end == c && git__isdigit(end[1]))
 		num3 = strtol(end+1, &end, 10);
 
 	/* Time? Date? */
@@ -348,7 +349,7 @@ static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_
 	case '.':
 	case '/':
 	case '-':
-		if (isdigit(end[1])) {
+		if (git__isdigit(end[1])) {
 			size_t match = match_multi_number(num, *end, date, end, tm);
 			if (match)
 				return match;
@@ -363,7 +364,7 @@ static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_
 	n = 0;
 	do {
 		n++;
-	} while (isdigit(date[n]));
+	} while (git__isdigit(date[n]));
 
 	/* Four-digit year or a timezone? */
 	if (n == 4) {
@@ -513,11 +514,11 @@ static int parse_date_basic(const char *date, git_time_t *timestamp, int *offset
 		if (!c || c == '\n')
 			break;
 
-		if (isalpha(c))
+		if (git__isalpha(c))
 			match = match_alpha(date, &tm, offset);
-		else if (isdigit(c))
+		else if (git__isdigit(c))
 			match = match_digit(date, &tm, offset, &tm_gmt);
-		else if ((c == '-' || c == '+') && isdigit(date[1]))
+		else if ((c == '-' || c == '+') && git__isdigit(date[1]))
 			match = match_tz(date, offset);
 
 		if (!match) {
@@ -681,7 +682,7 @@ static const char *approxidate_alpha(const char *date, struct tm *tm, struct tm
 	const char *end = date;
 	int i;
 
-	while (isalpha(*++end))
+	while (git__isalpha(*++end))
 		/* scan to non-alpha */;
 
 	for (i = 0; i < 12; i++) {
@@ -782,7 +783,7 @@ static const char *approxidate_digit(const char *date, struct tm *tm, int *num)
 	case '.':
 	case '/':
 	case '-':
-		if (isdigit(end[1])) {
+		if (git__isdigit(end[1])) {
 			size_t match = match_multi_number(number, *end, date, end, tm);
 			if (match)
 				return date + match;
@@ -842,22 +843,22 @@ static git_time_t approxidate_str(const char *date,
 		if (!c)
 			break;
 		date++;
-		if (isdigit(c)) {
+		if (git__isdigit(c)) {
 			pending_number(&tm, &number);
 			date = approxidate_digit(date-1, &tm, &number);
 			touched = 1;
 			continue;
 		}
-		if (isalpha(c))
+		if (git__isalpha(c))
 			date = approxidate_alpha(date-1, &tm, &now, &number, &touched);
 	}
 	pending_number(&tm, &number);
 	if (!touched)
-		*error_ret = 1;
+		*error_ret = -1;
 	return update_tm(&tm, &now, 0);
 }
 
-int git__date_parse(git_time_t *out, const char *date)
+int git_date_offset_parse(git_time_t *out, int *out_offset, const char *date)
 {
 	time_t time_sec;
 	git_time_t timestamp;
@@ -865,6 +866,7 @@ int git__date_parse(git_time_t *out, const char *date)
 
 	if (!parse_date_basic(date, &timestamp, &offset)) {
 		*out = timestamp;
+		*out_offset = offset;
 		return 0;
 	}
 
@@ -872,34 +874,34 @@ int git__date_parse(git_time_t *out, const char *date)
 		return -1;
 
 	*out = approxidate_str(date, time_sec, &error_ret);
-   return error_ret;
+	return error_ret;
 }
 
-int git__date_rfc2822_fmt(char *out, size_t len, const git_time *date)
+int git_date_parse(git_time_t *out, const char *date)
+{
+	int offset;
+
+	return git_date_offset_parse(out, &offset, date);
+}
+
+int git_date_rfc2822_fmt(git_str *out, git_time_t time, int offset)
 {
-	int written;
-	struct tm gmt;
 	time_t t;
+	struct tm gmt;
 
 	GIT_ASSERT_ARG(out);
-	GIT_ASSERT_ARG(date);
 
-	t = (time_t) (date->time + date->offset * 60);
+	t = (time_t) (time + offset * 60);
 
-	if (p_gmtime_r (&t, &gmt) == NULL)
+	if (p_gmtime_r(&t, &gmt) == NULL)
 		return -1;
 
-	written = p_snprintf(out, len, "%.3s, %u %.3s %.4u %02u:%02u:%02u %+03d%02d",
+	return git_str_printf(out, "%.3s, %u %.3s %.4u %02u:%02u:%02u %+03d%02d",
 		weekday_names[gmt.tm_wday],
 		gmt.tm_mday,
 		month_names[gmt.tm_mon],
 		gmt.tm_year + 1900,
 		gmt.tm_hour, gmt.tm_min, gmt.tm_sec,
-		date->offset / 60, date->offset % 60);
-
-	if (written < 0 || (written > (int) len - 1))
-		return -1;
-
-	return 0;
+		offset / 60, offset % 60);
 }
 

data/vendor/libgit2/src/util/date.h

@@ -0,0 +1,45 @@
+/*
+ * 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 INCLUDE_date_h__
+#define INCLUDE_date_h__
+
+#include "util.h"
+#include "str.h"
+
+/*
+ * Parse a string into a value as a git_time_t with a timezone offset.
+ *
+ * Sample valid input:
+ * - "yesterday"
+ * - "July 17, 2003"
+ * - "2003-7-17 08:23i+03"
+ */
+extern int git_date_offset_parse(git_time_t *out, int *out_offset, const char *date);
+
+/*
+ * Parse a string into a value as a git_time_t.
+ *
+ * Timezone offset is ignored.
+ *
+ * Sample valid input:
+ * - "yesterday"
+ * - "July 17, 2003"
+ * - "2003-7-17 08:23"
+ */
+extern int git_date_parse(git_time_t *out, const char *date);
+
+/*
+ * Format a git_time as a RFC2822 string
+ *
+ * @param out buffer to store formatted date
+ * @param time the time to be formatted
+ * @param offset the timezone offset
+ * @return 0 if successful; -1 on error
+ */
+extern int git_date_rfc2822_fmt(git_str *out, git_time_t time, int offset);
+
+#endif

data/vendor/libgit2/src/util/errors.c

@@ -0,0 +1,401 @@
+/*
+ * 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 "git2_util.h"
+
+#include "errors.h"
+#include "posix.h"
+#include "str.h"
+#include "runtime.h"
+
+/*
+ * Some static error data that is used when we're out of memory, TLS
+ * has not been setup, or TLS has failed.
+ */
+
+static git_error oom_error = {
+	"Out of memory",
+	GIT_ERROR_NOMEMORY
+};
+
+static git_error uninitialized_error = {
+	"library has not been initialized",
+	GIT_ERROR_INVALID
+};
+
+static git_error tlsdata_error = {
+	"thread-local data initialization failure",
+	GIT_ERROR_THREAD
+};
+
+static git_error no_error = {
+	"no error",
+	GIT_ERROR_NONE
+};
+
+#define IS_STATIC_ERROR(err) \
+	((err) == &oom_error || (err) == &uninitialized_error || \
+	 (err) == &tlsdata_error || (err) == &no_error)
+
+/* Per-thread error state (TLS) */
+
+static git_tlsdata_key tls_key;
+
+struct error_threadstate {
+	/* The error message buffer. */
+	git_str message;
+
+	/* Error information, set by `git_error_set` and friends. */
+	git_error error;
+
+	/*
+	 * The last error to occur; points to the error member of this
+	 * struct _or_ a static error.
+	 */
+	git_error *last;
+};
+
+static void threadstate_dispose(struct error_threadstate *threadstate)
+{
+	if (!threadstate)
+		return;
+
+	git_str_dispose(&threadstate->message);
+}
+
+static struct error_threadstate *threadstate_get(void)
+{
+	struct error_threadstate *threadstate;
+
+	if ((threadstate = git_tlsdata_get(tls_key)) != NULL)
+		return threadstate;
+
+	/*
+	 * Avoid git__malloc here, since if it fails, it sets an error
+	 * message, which requires thread state, which would allocate
+	 * here, which would fail, which would set an error message...
+	 */
+
+	if ((threadstate = git__allocator.gmalloc(
+			sizeof(struct error_threadstate),
+			__FILE__, __LINE__)) == NULL)
+		return NULL;
+
+	memset(threadstate, 0, sizeof(struct error_threadstate));
+
+	if (git_str_init(&threadstate->message, 0) < 0) {
+		git__allocator.gfree(threadstate);
+		return NULL;
+	}
+
+	git_tlsdata_set(tls_key, threadstate);
+	return threadstate;
+}
+
+static void GIT_SYSTEM_CALL threadstate_free(void *threadstate)
+{
+	threadstate_dispose(threadstate);
+	git__free(threadstate);
+}
+
+static void git_error_global_shutdown(void)
+{
+	struct error_threadstate *threadstate;
+
+	threadstate = git_tlsdata_get(tls_key);
+	git_tlsdata_set(tls_key, NULL);
+
+	threadstate_dispose(threadstate);
+	git__free(threadstate);
+
+	git_tlsdata_dispose(tls_key);
+}
+
+int git_error_global_init(void)
+{
+	if (git_tlsdata_init(&tls_key, &threadstate_free) != 0)
+		return -1;
+
+	return git_runtime_shutdown_register(git_error_global_shutdown);
+}
+
+static void set_error_from_buffer(int error_class)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+	git_error *error;
+	git_str *buf;
+
+	if (!threadstate)
+		return;
+
+	error = &threadstate->error;
+	buf = &threadstate->message;
+
+	error->message = buf->ptr;
+	error->klass = error_class;
+
+	threadstate->last = error;
+}
+
+static void set_error(int error_class, char *string)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+	git_str *buf;
+
+	if (!threadstate)
+		return;
+
+	buf = &threadstate->message;
+
+	git_str_clear(buf);
+
+	if (string)
+		git_str_puts(buf, string);
+
+	if (!git_str_oom(buf))
+		set_error_from_buffer(error_class);
+}
+
+void git_error_set_oom(void)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+
+	if (!threadstate)
+		return;
+
+	threadstate->last = &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
+
+	struct error_threadstate *threadstate = threadstate_get();
+	int error_code = (error_class == GIT_ERROR_OS) ? errno : 0;
+	git_str *buf;
+
+	if (!threadstate)
+		return;
+
+	buf = &threadstate->message;
+
+	git_str_clear(buf);
+
+	if (fmt) {
+		git_str_vprintf(buf, fmt, ap);
+		if (error_class == GIT_ERROR_OS)
+			git_str_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_str_puts(buf, win32_error);
+			git__free(win32_error);
+
+			SetLastError(0);
+		}
+		else
+#endif
+		if (error_code)
+			git_str_puts(buf, strerror(error_code));
+
+		if (error_code)
+			errno = 0;
+	}
+
+	if (!git_str_oom(buf))
+		set_error_from_buffer(error_class);
+}
+
+int git_error_set_str(int error_class, const char *string)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+	git_str *buf;
+
+	GIT_ASSERT_ARG(string);
+
+	if (!threadstate)
+		return -1;
+
+	buf = &threadstate->message;
+
+	git_str_clear(buf);
+	git_str_puts(buf, string);
+
+	if (git_str_oom(buf))
+		return -1;
+
+	set_error_from_buffer(error_class);
+	return 0;
+}
+
+void git_error_clear(void)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+
+	if (!threadstate)
+		return;
+
+	if (threadstate->last != NULL) {
+		set_error(0, NULL);
+		threadstate->last = NULL;
+	}
+
+	errno = 0;
+#ifdef GIT_WIN32
+	SetLastError(0);
+#endif
+}
+
+bool git_error_exists(void)
+{
+	struct error_threadstate *threadstate;
+
+	if ((threadstate = threadstate_get()) == NULL)
+		return true;
+
+	return threadstate->last != NULL;
+}
+
+const git_error *git_error_last(void)
+{
+	struct error_threadstate *threadstate;
+
+	/* If the library is not initialized, return a static error. */
+	if (!git_runtime_init_count())
+		return &uninitialized_error;
+
+	if ((threadstate = threadstate_get()) == NULL)
+		return &tlsdata_error;
+
+	if (!threadstate->last)
+		return &no_error;
+
+	return threadstate->last;
+}
+
+int git_error_save(git_error **out)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+	git_error *error, *dup;
+
+	if (!threadstate) {
+		*out = &tlsdata_error;
+		return -1;
+	}
+
+	error = threadstate->last;
+
+	if (!error || error == &no_error) {
+		*out = &no_error;
+		return 0;
+	} else if (IS_STATIC_ERROR(error)) {
+		*out = error;
+		return 0;
+	}
+
+	if ((dup = git__malloc(sizeof(git_error))) == NULL) {
+		*out = &oom_error;
+		return -1;
+	}
+
+	dup->klass = error->klass;
+	dup->message = git__strdup(error->message);
+
+	if (!dup->message) {
+		*out = &oom_error;
+		return -1;
+	}
+
+	*out = dup;
+	return 0;
+}
+
+int git_error_restore(git_error *error)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+
+	GIT_ASSERT_ARG(error);
+
+	if (IS_STATIC_ERROR(error) && threadstate)
+		threadstate->last = error;
+	else
+		set_error(error->klass, error->message);
+
+	git_error_free(error);
+	return 0;
+}
+
+void git_error_free(git_error *error)
+{
+	if (!error)
+		return;
+
+	if (IS_STATIC_ERROR(error))
+		return;
+
+	git__free(error->message);
+	git__free(error);
+}
+
+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
+
+#include "git2/deprecated.h"
+
+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