Fix warnings on Win64 build

include/git2/index.h

@@ -258,7 +258,7 @@ GIT_EXTERN(int) git_index_write_tree_to(git_oid *out, git_index *index, git_repo
  * @param index an existing index object
  * @return integer of count of current entries
  */
-GIT_EXTERN(unsigned int) git_index_entrycount(const git_index *index);
+GIT_EXTERN(size_t) git_index_entrycount(const git_index *index);
 
 /**
  * Clear the contents (all the entries) of an index object.

src/delta.c

@@ -148,7 +148,7 @@ git_delta_create_index(const void *buf, unsigned long bufsize)
 	/* Determine index hash size.  Note that indexing skips the
 	   first byte to allow for optimizing the Rabin's polynomial
 	   initialization in create_delta(). */
-	entries = (bufsize - 1) / RABIN_WINDOW;
+	entries = (unsigned int)(bufsize - 1) / RABIN_WINDOW;
 	if (bufsize >= 0xffffffffUL) {
 		/*
 		 * Current delta format can't encode offsets into
@@ -317,9 +317,12 @@ unsigned long git_delta_sizeof_index(struct git_delta_index *index)
 #define MAX_OP_SIZE	(5 + 5 + 1 + RABIN_WINDOW + 7)
 
 void *
-git_delta_create(const struct git_delta_index *index,
-		 const void *trg_buf, unsigned long trg_size,
-		 unsigned long *delta_size, unsigned long max_size)
+git_delta_create(
+	const struct git_delta_index *index,
+	const void *trg_buf,
+	unsigned long trg_size,
+	unsigned long *delta_size,
+	unsigned long max_size)
 {
 	unsigned int i, outpos, outsize, moff, msize, val;
 	int inscnt;
@@ -332,7 +335,7 @@ git_delta_create(const struct git_delta_index *index,
 	outpos = 0;
 	outsize = 8192;
 	if (max_size && outsize >= max_size)
-		outsize = max_size + MAX_OP_SIZE + 1;
+		outsize = (unsigned int)(max_size + MAX_OP_SIZE + 1);
 	out = git__malloc(outsize);
 	if (!out)
 		return NULL;
@@ -377,19 +380,19 @@ git_delta_create(const struct git_delta_index *index,
 			for (entry = index->hash[i]; entry < index->hash[i+1]; entry++) {
 				const unsigned char *ref = entry->ptr;
 				const unsigned char *src = data;
-				unsigned int ref_size = ref_top - ref;
+				unsigned int ref_size = (unsigned int)(ref_top - ref);
 				if (entry->val != val)
 					continue;
 				if (ref_size > (unsigned int)(top - src))
-					ref_size = top - src;
+					ref_size = (unsigned int)(top - src);
 				if (ref_size <= msize)
 					break;
 				while (ref_size-- && *src++ == *ref)
 					ref++;
 				if (msize < (unsigned int)(ref - entry->ptr)) {
 					/* this is our best match so far */
-					msize = ref - entry->ptr;
-					moff = entry->ptr - ref_data;
+					msize = (unsigned int)(ref - entry->ptr);
+					moff = (unsigned int)(entry->ptr - ref_data);
 					if (msize >= 4096) /* good enough */
 						break;
 				}

src/delta.h

@@ -46,11 +46,12 @@ extern unsigned long git_delta_sizeof_index(struct git_delta_index *index);
  * returned and *delta_size is updated with its size.  The returned buffer
  * must be freed by the caller.
  */
-extern void *
-git_delta_create(const struct git_delta_index *index,
-		 const void *buf, unsigned long bufsize,
-		 unsigned long *delta_size,
-		 unsigned long max_delta_size);
+extern void *git_delta_create(
+	const struct git_delta_index *index,
+	const void *buf,
+	unsigned long bufsize,
+	unsigned long *delta_size,
+	unsigned long max_delta_size);
 
 /*
  * diff_delta: create a delta from source buffer to target buffer
@@ -60,15 +61,16 @@ git_delta_create(const struct git_delta_index *index,
  * pointer to the buffer with the delta data is returned and *delta_size is
  * updated with its size.  The returned buffer must be freed by the caller.
  */
-GIT_INLINE(void *)
-git_delta(const void *src_buf, unsigned long src_bufsize,
-	  const void *trg_buf, unsigned long trg_bufsize,
-	  unsigned long *delta_size, unsigned long max_delta_size)
+GIT_INLINE(void *) git_delta(
+	const void *src_buf, unsigned long src_bufsize,
+	const void *trg_buf, unsigned long trg_bufsize,
+	unsigned long *delta_size,
+	unsigned long max_delta_size)
 {
 	struct git_delta_index *index = git_delta_create_index(src_buf, src_bufsize);
 	if (index) {
-		void *delta = git_delta_create(index, trg_buf, trg_bufsize,
-					       delta_size, max_delta_size);
+		void *delta = git_delta_create(
+			index, trg_buf, trg_bufsize, delta_size, max_delta_size);
 		git_delta_free_index(index);
 		return delta;
 	}
@@ -82,9 +84,10 @@ git_delta(const void *src_buf, unsigned long src_bufsize,
  * *trg_bufsize is updated with its size.  On failure a NULL pointer is
  * returned.  The returned buffer must be freed by the caller.
  */
-extern void *git_delta_patch(const void *src_buf, unsigned long src_size,
-			     const void *delta_buf, unsigned long delta_size,
-			     unsigned long *dst_size);
+extern void *git_delta_patch(
+	const void *src_buf, unsigned long src_size,
+	const void *delta_buf, unsigned long delta_size,
+	unsigned long *dst_size);
 
 /* the smallest possible delta size is 4 bytes */
 #define GIT_DELTA_SIZE_MIN	4
@@ -93,9 +96,8 @@ extern void *git_delta_patch(const void *src_buf, unsigned long src_size,
  * This must be called twice on the delta data buffer, first to get the
  * expected source buffer size, and again to get the target buffer size.
  */
-GIT_INLINE(unsigned long)
-git_delta_get_hdr_size(const unsigned char **datap,
-		       const unsigned char *top)
+GIT_INLINE(unsigned long) git_delta_get_hdr_size(
+	const unsigned char **datap, const unsigned char *top)
 {
 	const unsigned char *data = *datap;
 	unsigned long cmd, size = 0;

src/diff_output.c

@@ -262,7 +262,7 @@ static int get_blob_content(
 		return error;
 
 	map->data = (void *)git_blob_rawcontent(*blob);
-	map->len  = git_blob_rawsize(*blob);
+	map->len  = (size_t)git_blob_rawsize(*blob);
 
 	return diff_delta_is_binary_by_content(ctxt, delta, file, map);
 }
@@ -1236,14 +1236,18 @@ static void set_data_from_blob(
 	git_blob *blob, git_map *map, git_diff_file *file)
 {
 	if (blob) {
-		map->data = (char *)git_blob_rawcontent(blob);
-		file->size = map->len = git_blob_rawsize(blob);
+		file->size = git_blob_rawsize(blob);
 		git_oid_cpy(&file->oid, git_object_id((const git_object *)blob));
 		file->mode = 0644;
+
+		map->len   = (size_t)file->size;
+		map->data  = (char *)git_blob_rawcontent(blob);
 	} else {
-		map->data = "";
-		file->size = map->len = 0;
+		file->size = 0;
 		file->flags |= GIT_DIFF_FILE_NO_DATA;
+
+		map->len   = 0;
+		map->data  = "";
 	}
 }
 

src/hash/hash_win32.c

@@ -155,7 +155,7 @@ GIT_INLINE(int) hash_cryptoapi_update(git_hash_ctx *ctx, const void *data, size_
 {
 	assert(ctx->ctx.cryptoapi.valid);
 
-	if (!CryptHashData(ctx->ctx.cryptoapi.hash_handle, (const BYTE *)data, len, 0))
+	if (!CryptHashData(ctx->ctx.cryptoapi.hash_handle, (const BYTE *)data, (DWORD)len, 0))
 		return -1;
 
 	return 0;
@@ -219,7 +219,7 @@ GIT_INLINE(int) hash_cng_init(git_hash_ctx *ctx)
 
 GIT_INLINE(int) hash_cng_update(git_hash_ctx *ctx, const void *data, size_t len)
 {
-	if (ctx->prov->prov.cng.hash_data(ctx->ctx.cng.hash_handle, (PBYTE)data, len, 0) < 0)
+	if (ctx->prov->prov.cng.hash_data(ctx->ctx.cng.hash_handle, (PBYTE)data, (ULONG)len, 0) < 0)
 		return -1;
 
 	return 0;

src/index.c

@@ -488,10 +488,10 @@ int git_index_write_tree_to(git_oid *oid, git_index *index, git_repository *repo
 	return git_tree__write_index(oid, index, repo);
 }
 
-unsigned int git_index_entrycount(const git_index *index)
+size_t git_index_entrycount(const git_index *index)
 {
 	assert(index);
-	return (unsigned int)index->entries.length;
+	return index->entries.length;
 }
 
 const git_index_entry *git_index_get_byindex(
@@ -852,7 +852,7 @@ int git_index_conflict_add(git_index *index,
 	const git_index_entry *their_entry)
 {
 	git_index_entry *entries[3] = { 0 };
-	size_t i;
+	unsigned short i;
 	int ret = 0;
 
 	assert (index);
@@ -890,7 +890,7 @@ int git_index_conflict_get(git_index_entry **ancestor_out,
 	git_index_entry **their_out,
 	git_index *index, const char *path)
 {
-	int pos, stage;
+	int pos, posmax, stage;
 	git_index_entry *conflict_entry;
 	int error = GIT_ENOTFOUND;
 
@@ -903,7 +903,8 @@ int git_index_conflict_get(git_index_entry **ancestor_out,
 	if ((pos = git_index_find(index, path)) < 0)
 		return pos;
 
-	while ((unsigned int)pos < git_index_entrycount(index)) {
+	for (posmax = (int)git_index_entrycount(index); pos < posmax; ++pos) {
+
 		conflict_entry = git_vector_get(&index->entries, pos);
 
 		if (index->entries_cmp_path(conflict_entry->path, path) != 0)
@@ -927,8 +928,6 @@ int git_index_conflict_get(git_index_entry **ancestor_out,
 		default:
 			break;
 		};
-
-		++pos;
 	}
 
 	return error;
@@ -936,7 +935,7 @@ int git_index_conflict_get(git_index_entry **ancestor_out,
 
 int git_index_conflict_remove(git_index *index, const char *path)
 {
-	int pos;
+	int pos, posmax;
 	git_index_entry *conflict_entry;
 	int error = 0;
 
@@ -945,7 +944,9 @@ int git_index_conflict_remove(git_index *index, const char *path)
 	if ((pos = git_index_find(index, path)) < 0)
 		return pos;
 
-	while ((unsigned int)pos < git_index_entrycount(index)) {
+	posmax = (int)git_index_entrycount(index);
+
+	while (pos < posmax) {
 		conflict_entry = git_vector_get(&index->entries, pos);
 
 		if (index->entries_cmp_path(conflict_entry->path, path) != 0)
@@ -1520,7 +1521,7 @@ static int write_reuc_extension(git_index *index, git_filebuf *file)
 
 	memset(&extension, 0x0, sizeof(struct index_extension));
 	memcpy(&extension.signature, INDEX_EXT_UNMERGED_SIG, 4);
-	extension.extension_size = reuc_buf.size;
+	extension.extension_size = (uint32_t)reuc_buf.size;
 
 	error = write_extension(file, &extension, &reuc_buf);
 

src/iterator.c

@@ -329,7 +329,7 @@ int git_iterator_for_tree_range(
 typedef struct {
 	git_iterator base;
 	git_index *index;
-	unsigned int current;
+	size_t current;
 	bool free_index;
 } index_iterator;
 

src/pack-objects.c

@@ -229,7 +229,7 @@ static int gen_pack_object_header(
 	}
 	*hdr++ = c;
 
-	return hdr - hdr_base;
+	return (int)(hdr - hdr_base);
 }
 
 static int get_delta(void **out, git_odb *odb, git_pobject *po)
@@ -244,9 +244,10 @@ static int get_delta(void **out, git_odb *odb, git_pobject *po)
 	    git_odb_read(&trg, odb, &po->id) < 0)
 		goto on_error;
 
-	delta_buf = git_delta(git_odb_object_data(src), git_odb_object_size(src),
-			      git_odb_object_data(trg), git_odb_object_size(trg),
-			      &delta_size, 0);
+	delta_buf = git_delta(
+		git_odb_object_data(src), (unsigned long)git_odb_object_size(src),
+		git_odb_object_data(trg), (unsigned long)git_odb_object_size(trg),
+		&delta_size, 0);
 
 	if (!delta_buf || delta_size != po->delta_size) {
 		giterr_set(GITERR_INVALID, "Delta size changed");
@@ -287,7 +288,7 @@ static int write_object(git_buf *buf, git_packbuilder *pb, git_pobject *po)
 			goto on_error;
 
 		data = (void *)git_odb_object_data(obj);
-		size = git_odb_object_size(obj);
+		size = (unsigned long)git_odb_object_size(obj);
 		type = git_odb_object_type(obj);
 	}
 
@@ -315,7 +316,7 @@ static int write_object(git_buf *buf, git_packbuilder *pb, git_pobject *po)
 		if (po->delta)
 			git__free(data);
 		data = zbuf.ptr;
-		size = zbuf.size;
+		size = (unsigned long)zbuf.size;
 	}
 
 	if (git_buf_put(buf, data, size) < 0 ||
@@ -707,7 +708,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 		return 0;
 
 	/* Now some size filtering heuristics. */
-	trg_size = trg_object->size;
+	trg_size = (unsigned long)trg_object->size;
 	if (!trg_object->delta) {
 		max_size = trg_size/2 - 20;
 		ref_depth = 1;
@@ -721,7 +722,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 	if (max_size == 0)
 		return 0;
 
-	src_size = src_object->size;
+	src_size = (unsigned long)src_object->size;
 	sizediff = src_size < trg_size ? trg_size - src_size : 0;
 	if (sizediff >= max_size)
 		return 0;
@@ -733,7 +734,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 		if (git_odb_read(&obj, pb->odb, &trg_object->id) < 0)
 			return -1;
 
-		sz = git_odb_object_size(obj);
+		sz = (unsigned long)git_odb_object_size(obj);
 		trg->data = git__malloc(sz);
 		GITERR_CHECK_ALLOC(trg->data);
 		memcpy(trg->data, git_odb_object_data(obj), sz);
@@ -752,7 +753,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 		if (git_odb_read(&obj, pb->odb, &src_object->id) < 0)
 			return -1;
 
-		sz = git_odb_object_size(obj);
+		sz = (unsigned long)git_odb_object_size(obj);
 		src->data = git__malloc(sz);
 		GITERR_CHECK_ALLOC(src->data);
 		memcpy(src->data, git_odb_object_data(obj), sz);
@@ -835,7 +836,7 @@ static unsigned long free_unpacked(struct unpacked *n)
 	git_delta_free_index(n->index);
 	n->index = NULL;
 	if (n->data) {
-		freed_mem += n->object->size;
+		freed_mem += (unsigned long)n->object->size;
 		git__free(n->data);
 		n->data = NULL;
 	}
@@ -941,7 +942,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 			GITERR_CHECK_ALLOC(po->delta_data);
 
 			memcpy(po->delta_data, zbuf.ptr, zbuf.size);
-			po->z_delta_size = zbuf.size;
+			po->z_delta_size = (unsigned long)zbuf.size;
 			git_buf_clear(&zbuf);
 
 			git_packbuilder__cache_lock(pb);

src/reflog.c

@@ -275,7 +275,7 @@ int git_reflog_write(git_reflog *reflog)
 		if ((error = git_filebuf_write(&fbuf, log.ptr, log.size)) < 0)
 			goto cleanup;
 	}
-	
+
 	error = git_filebuf_commit(&fbuf, GIT_REFLOG_FILE_MODE);
 	goto success;
 
@@ -411,18 +411,20 @@ size_t git_reflog_entrycount(git_reflog *reflog)
 	return reflog->entries.length;
 }
 
-const git_reflog_entry * git_reflog_entry_byindex(git_reflog *reflog, size_t idx)
+GIT_INLINE(size_t) reflog_inverse_index(size_t idx, size_t total)
 {
-	int pos;
+	return (total - 1) - idx;
+}
 
+const git_reflog_entry * git_reflog_entry_byindex(git_reflog *reflog, size_t idx)
+{
 	assert(reflog);
 
-	pos = git_reflog_entrycount(reflog) - (idx + 1);
-
-	if (pos < 0)
+	if (idx >= reflog->entries.length)
 		return NULL;
 
-	return git_vector_get(&reflog->entries, pos);
+	return git_vector_get(
+		&reflog->entries, reflog_inverse_index(idx, reflog->entries.length));
 }
 
 const git_oid * git_reflog_entry_id_old(const git_reflog_entry *entry)
@@ -454,7 +456,7 @@ int git_reflog_drop(
 	size_t idx,
 	int rewrite_previous_entry)
 {
-	unsigned int entrycount;
+	size_t entrycount;
 	git_reflog_entry *entry, *previous;
 
 	assert(reflog);
@@ -468,7 +470,8 @@ int git_reflog_drop(
 
 	reflog_entry_free(entry);
 
-	if (git_vector_remove(&reflog->entries, entrycount - (idx + 1)) < 0)
+	if (git_vector_remove(
+			&reflog->entries, reflog_inverse_index(idx, entrycount)) < 0)
 		return -1;
 
 	if (!rewrite_previous_entry)
@@ -489,7 +492,7 @@ int git_reflog_drop(
 		/* ...clear the oid_old member of the "new" oldest entry */
 		if (git_oid_fromstr(&entry->oid_old, GIT_OID_HEX_ZERO) < 0)
 			return -1;
-		
+
 		return 0;
 	}
 

src/revparse.c

@@ -161,7 +161,7 @@ static int revparse_lookup_object(git_object **out, git_repository *repo, const
 
 static int try_parse_numeric(int *n, const char *curly_braces_content)
 {
-	int content;
+	int32_t content;
 	const char *end_ptr;
 
 	if (git__strtol32(&content, curly_braces_content, &end_ptr, 10) < 0)
@@ -170,16 +170,17 @@ static int try_parse_numeric(int *n, const char *curly_braces_content)
 	if (*end_ptr != '\0')
 		return -1;
 
-	*n = content;
+	*n = (int)content;
 	return 0;
 }
 
-static int retrieve_previously_checked_out_branch_or_revision(git_object **out, git_reference **base_ref, git_repository *repo, const char *spec, const char *identifier, unsigned int position)
+static int retrieve_previously_checked_out_branch_or_revision(git_object **out, git_reference **base_ref, git_repository *repo, const char *spec, const char *identifier, size_t position)
 {
 	git_reference *ref = NULL;
 	git_reflog *reflog = NULL;
 	regex_t preg;
-	int numentries, i, cur, error = -1;
+	int error = -1;
+	size_t i, numentries, cur;
 	const git_reflog_entry *entry;
 	const char *msg;
 	regmatch_t regexmatches[2];
@@ -204,7 +205,7 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out,
 	for (i = 0; i < numentries; i++) {
 		entry = git_reflog_entry_byindex(reflog, i);
 		msg = git_reflog_entry_message(entry);
-		
+
 		if (regexec(&preg, msg, 2, regexmatches, 0))
 			continue;
 
@@ -212,7 +213,7 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out,
 
 		if (cur > 0)
 			continue;
-		
+
 		git_buf_put(&buf, msg+regexmatches[1].rm_so, regexmatches[1].rm_eo - regexmatches[1].rm_so);
 
 		if ((error = disambiguate_refname(base_ref, repo, git_buf_cstr(&buf))) == 0)
@@ -225,7 +226,7 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out,
 
 		goto cleanup;
 	}
-	
+
 	error = GIT_ENOTFOUND;
 
 cleanup:
@@ -236,27 +237,25 @@ cleanup:
 	return error;
 }
 
-static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, unsigned int identifier)
+static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, size_t identifier)
 {
 	git_reflog *reflog;
 	int error = -1;
-	unsigned int numentries;
+	size_t numentries;
 	const git_reflog_entry *entry;
 	bool search_by_pos = (identifier <= 100000000);
 
 	if (git_reflog_read(&reflog, ref) < 0)
 		return -1;
 
-	numentries  = git_reflog_entrycount(reflog);
+	numentries = git_reflog_entrycount(reflog);
 
 	if (search_by_pos) {
 		if (numentries < identifier + 1) {
 			giterr_set(
 				GITERR_REFERENCE,
-				"Reflog for '%s' has only %d entries, asked for %d",
-				git_reference_name(ref),
-				numentries,
-				identifier);
+				"Reflog for '%s' has only "PRIuZ" entries, asked for "PRIuZ,
+				git_reference_name(ref), numentries, identifier);
 
 			error = GIT_ENOTFOUND;
 			goto cleanup;
@@ -268,14 +267,14 @@ static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, unsigned i
 		goto cleanup;
 
 	} else {
-		unsigned int i;
+		size_t i;
 		git_time commit_time;
 
 		for (i = 0; i < numentries; i++) {
 			entry = git_reflog_entry_byindex(reflog, i);
 			commit_time = git_reflog_entry_committer(entry)->when;
-					
-			if (commit_time.time - identifier > 0)
+
+			if (commit_time.time > (git_time_t)identifier)
 				continue;
 
 			git_oid_cpy(oid, git_reflog_entry_id_new(entry));
@@ -291,7 +290,7 @@ cleanup:
 	return error;
 }
 
-static int retrieve_revobject_from_reflog(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, unsigned int position)
+static int retrieve_revobject_from_reflog(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, size_t position)
 {
 	git_reference *ref;
 	git_oid oid;
@@ -380,7 +379,7 @@ static int handle_at_syntax(git_object **out, git_reference **ref, const char *s
 	if (git__date_parse(&timestamp, curly_braces_content) < 0)
 		goto cleanup;
 
-	error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), (unsigned int)timestamp);
+	error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), (size_t)timestamp);
 
 cleanup:
 	git_buf_free(&identifier);
@@ -394,7 +393,7 @@ static git_otype parse_obj_type(const char *str)
 
 	if (!strcmp(str, "tree"))
 		return GIT_OBJ_TREE;
-	
+
 	if (!strcmp(str, "blob"))
 		return GIT_OBJ_BLOB;
 

src/stash.c

@@ -56,7 +56,7 @@ static int append_abbreviated_oid(git_buf *out, const git_oid *b_commit)
 static int append_commit_description(git_buf *out, git_commit* commit)
 {
 	const char *message;
-	int pos = 0, len;
+	size_t pos = 0, len;
 
 	if (append_abbreviated_oid(out, git_commit_id(commit)) < 0)
 		return -1;

src/transports/cred.c

@@ -11,7 +11,7 @@
 static void plaintext_free(struct git_cred *cred)
 {
 	git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;
-	int pass_len = strlen(c->password);
+	size_t pass_len = strlen(c->password);
 
 	git__free(c->username);
 
@@ -19,6 +19,8 @@ static void plaintext_free(struct git_cred *cred)
 	memset(c->password, 0x0, pass_len);
 	git__free(c->password);
 
+	memset(c, 0, sizeof(*c));
+
 	git__free(c);
 }
 
@@ -54,4 +56,4 @@ int git_cred_userpass_plaintext_new(
 
 	*cred = &c->parent;
 	return 0;
-}
\ No newline at end of file
+}

src/transports/smart.c

@@ -24,7 +24,7 @@ static int git_smart__recv_cb(gitno_buffer *buf)
 	buf->offset += bytes_read;
 
 	if (t->packetsize_cb)
-		t->packetsize_cb(bytes_read, t->packetsize_payload);
+		t->packetsize_cb((int)bytes_read, t->packetsize_payload);
 
 	return (int)(buf->offset - old_len);
 }

src/transports/smart.h

@@ -94,7 +94,7 @@ typedef struct transport_smart_caps {
 		include_tag:1;
 } transport_smart_caps;
 
-typedef void (*packetsize_cb)(int received, void *payload);
+typedef void (*packetsize_cb)(size_t received, void *payload);
 
 typedef struct {
 	git_transport parent;

src/transports/smart_protocol.c

@@ -367,7 +367,7 @@ static int no_sideband(transport_smart *t, struct git_odb_writepack *writepack,
 	return 0;
 }
 
-struct network_packetsize_payload	
+struct network_packetsize_payload
 {
 	git_transfer_progress_callback callback;
 	void *payload;
@@ -375,7 +375,7 @@ struct network_packetsize_payload
 	size_t last_fired_bytes;
 };
 
-static void network_packetsize(int received, void *payload)
+static void network_packetsize(size_t received, void *payload)
 {
 	struct network_packetsize_payload *npp = (struct network_packetsize_payload*)payload;
 
@@ -384,8 +384,8 @@ static void network_packetsize(int received, void *payload)
 
 	/* Fire notification if the threshold is reached */
 	if ((npp->stats->received_bytes - npp->last_fired_bytes) > NETWORK_XFER_THRESHOLD) {
-		npp->last_fired_bytes = npp->stats->received_bytes;	
-		npp->callback(npp->stats, npp->payload);	
+		npp->last_fired_bytes = npp->stats->received_bytes;
+		npp->callback(npp->stats, npp->payload);
 	}
 }
 
@@ -414,7 +414,7 @@ int git_smart__download_pack(
 
 		/* We might have something in the buffer already from negotiate_fetch */
 		if (t->buffer.offset > 0)
-			t->packetsize_cb(t->buffer.offset, t->packetsize_payload);
+			t->packetsize_cb((int)t->buffer.offset, t->packetsize_payload);
 	}
 
 	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||

src/transports/winhttp.c

@@ -376,7 +376,7 @@ replay:
 
 	if (!WinHttpReadData(s->request,
 		(LPVOID)buffer,
-		buf_size,
+		(DWORD)buf_size,
 		&dw_bytes_read))
 	{
 		giterr_set(GITERR_OS, "Failed to read data");

src/tree.c

@@ -353,10 +353,9 @@ int git_tree__parse(git_tree *tree, git_odb_object *obj)
 	return tree_parse_buffer(tree, (char *)obj->raw.data, (char *)obj->raw.data + obj->raw.len);
 }
 
-static unsigned int find_next_dir(const char *dirname, git_index *index, unsigned int start)
+static size_t find_next_dir(const char *dirname, git_index *index, size_t start)
 {
-	unsigned int i, entries = git_index_entrycount(index);
-	size_t dirlen;
+	size_t dirlen, i, entries = git_index_entrycount(index);
 
 	dirlen = strlen(dirname);
 	for (i = start; i < entries; ++i) {
@@ -399,11 +398,10 @@ static int write_tree(
 	git_repository *repo,
 	git_index *index,
 	const char *dirname,
-	unsigned int start)
+	size_t start)
 {
 	git_treebuilder *bld = NULL;
-
-	unsigned int i, entries = git_index_entrycount(index);
+	size_t i, entries = git_index_entrycount(index);
 	int error;
 	size_t dirname_len = strlen(dirname);
 	const git_tree_cache *cache;
@@ -411,13 +409,11 @@ static int write_tree(
 	cache = git_tree_cache_get(index->tree, dirname);
 	if (cache != NULL && cache->entries >= 0){
 		git_oid_cpy(oid, &cache->oid);
-		return find_next_dir(dirname, index, start);
+		return (int)find_next_dir(dirname, index, start);
 	}
 
-	error = git_treebuilder_create(&bld, NULL);
-	if (bld == NULL) {
+	if ((error = git_treebuilder_create(&bld, NULL)) < 0 || bld == NULL)
 		return -1;
-	}
 
 	/*
 	 * This loop is unfortunate, but necessary. The index doesn't have
@@ -494,7 +490,7 @@ static int write_tree(
 		goto on_error;
 
 	git_treebuilder_free(bld);
-	return i;
+	return (int)i;
 
 on_error:
 	git_treebuilder_free(bld);

src/vector.c

@@ -165,7 +165,7 @@ int git_vector_search2(
 
 	for (i = 0; i < v->length; ++i) {
 		if (key_lookup(key, v->contents[i]) == 0)
-			return i;
+			return (int)i;
 	}
 
 	return GIT_ENOTFOUND;

src/win32/posix_w32.c

@@ -520,17 +520,17 @@ int p_inet_pton(int af, const char* src, void* dst)
 		struct sockaddr_in6 sin6;
 		struct sockaddr_in sin;
 	} sa;
-	size_t srcsize;
+	int srcsize;
 
 	switch(af)
 	{
 		case AF_INET:
 			sa.sin.sin_family = AF_INET;
-			srcsize = sizeof (sa.sin);
+			srcsize = (int)sizeof(sa.sin);
 		break;
 		case AF_INET6:
 			sa.sin6.sin6_family = AF_INET6;
-			srcsize = sizeof (sa.sin6);
+			srcsize = (int)sizeof(sa.sin6);
 		break;
 		default:
 			errno = WSAEPFNOSUPPORT;

tests-clar/diff/patch.c

@@ -113,7 +113,7 @@ void test_diff_patch__to_string(void)
 
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, one, another, NULL));
 
-	cl_assert_equal_i(1, git_diff_num_deltas(diff));
+	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_diff_get_patch(&patch, NULL, diff, 0));
 

tests-clar/index/conflicts.c

@@ -134,7 +134,7 @@ void test_index_conflicts__remove(void)
 {
 	const git_index_entry *entry;
 	size_t i;
-	
+
 	cl_assert(git_index_entrycount(repo_index) == 8);
 
 	cl_git_pass(git_index_conflict_remove(repo_index, "conflicts-one.txt"));

tests-clar/index/filemodes.c

@@ -22,7 +22,7 @@ void test_index_filemodes__read(void)
 	static bool expected[6] = { 0, 1, 0, 1, 0, 1 };
 
 	cl_git_pass(git_repository_index(&index, g_repo));
-	cl_assert_equal_i(6, git_index_entrycount(index));
+	cl_assert_equal_i(6, (int)git_index_entrycount(index));
 
 	for (i = 0; i < 6; ++i) {
 		const git_index_entry *entry = git_index_get_byindex(index, i);

tests-clar/index/inmemory.c

@@ -5,7 +5,7 @@ void test_index_inmemory__can_create_an_inmemory_index(void)
 	git_index *index;
 
 	cl_git_pass(git_index_new(&index));
-	cl_assert_equal_i(0, git_index_entrycount(index));
+	cl_assert_equal_i(0, (int)git_index_entrycount(index));
 
 	git_index_free(index);
 }

tests-clar/index/tests.c

 #include "clar_libgit2.h"
 #include "index.h"
 
-static const int index_entry_count = 109;
-static const int index_entry_count_2 = 1437;
+static const size_t index_entry_count = 109;
+static const size_t index_entry_count_2 = 1437;
 #define TEST_INDEX_PATH cl_fixture("testrepo.git/index")
 #define TEST_INDEX2_PATH cl_fixture("gitgit.index")
 #define TEST_INDEXBIG_PATH cl_fixture("big.index")
@@ -99,7 +99,7 @@ void test_index_tests__default_test_index(void)
    cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));
    cl_assert(index->on_disk);
 
-   cl_assert(git_index_entrycount(index) == (unsigned int)index_entry_count);
+   cl_assert(git_index_entrycount(index) == index_entry_count);
    cl_assert(index->entries.sorted);
 
    entries = (git_index_entry **)index->entries.contents;
@@ -122,7 +122,7 @@ void test_index_tests__gitgit_index(void)
    cl_git_pass(git_index_open(&index, TEST_INDEX2_PATH));
    cl_assert(index->on_disk);
 
-   cl_assert(git_index_entrycount(index) == (unsigned int)index_entry_count_2);
+   cl_assert(git_index_entrycount(index) == index_entry_count_2);
    cl_assert(index->entries.sorted);
    cl_assert(index->tree != NULL);
 

tests-clar/network/fetch.c

@@ -29,7 +29,7 @@ static int update_tips(const char *refname, const git_oid *a, const git_oid *b,
 
 static void progress(const git_transfer_progress *stats, void *payload)
 {
-	int *bytes_received = (int*)payload;
+	size_t *bytes_received = (size_t *)payload;
 	*bytes_received = stats->received_bytes;
 }
 
@@ -37,7 +37,7 @@ static void do_fetch(const char *url, int flag, int n)
 {
 	git_remote *remote;
 	git_remote_callbacks callbacks;
-	int bytes_received = 0;
+	size_t bytes_received = 0;
 
 	memset(&callbacks, 0, sizeof(git_remote_callbacks));
 	callbacks.update_tips = update_tips;

tests-clar/network/fetchlocal.c

@@ -27,7 +27,7 @@ void test_network_fetchlocal__complete(void)
 	cl_git_pass(git_remote_update_tips(origin));
 
 	cl_git_pass(git_reference_list(&refnames, repo, GIT_REF_LISTALL));
-	cl_assert_equal_i(18, refnames.count);
+	cl_assert_equal_i(18, (int)refnames.count);
 	cl_assert(callcount > 0);
 
 	git_strarray_free(&refnames);
@@ -44,7 +44,7 @@ void test_network_fetchlocal__partial(void)
 	const char *url;
 
 	cl_git_pass(git_reference_list(&refnames, repo, GIT_REF_LISTALL));
-	cl_assert_equal_i(1, refnames.count);
+	cl_assert_equal_i(1, (int)refnames.count);
 
 	url = cl_git_fixture_url("testrepo.git");
 	cl_git_pass(git_remote_add(&origin, repo, GIT_REMOTE_ORIGIN, url));
@@ -55,7 +55,7 @@ void test_network_fetchlocal__partial(void)
 	git_strarray_free(&refnames);
 
 	cl_git_pass(git_reference_list(&refnames, repo, GIT_REF_LISTALL));
-	cl_assert_equal_i(19, refnames.count); /* 18 remote + 1 local */
+	cl_assert_equal_i(19, (int)refnames.count); /* 18 remote + 1 local */
 	cl_assert(callcount > 0);
 
 	git_strarray_free(&refnames);

tests-clar/object/blob/filter.c

@@ -43,7 +43,7 @@ void test_object_blob_filter__initialize(void)
 
 	for (i = 0; i < NUM_TEST_OBJECTS; i++) {
 		size_t len = (g_len[i] < 0) ? strlen(g_raw[i]) : (size_t)g_len[i];
-		g_len[i] = (int)len;
+		g_len[i] = (git_off_t)len;
 
 		cl_git_pass(
 			git_blob_create_frombuffer(&g_oids[i], g_repo, g_raw[i], len)
@@ -66,7 +66,7 @@ void test_object_blob_filter__unfiltered(void)
 	for (i = 0; i < NUM_TEST_OBJECTS; i++) {
 		cl_git_pass(git_blob_lookup(&blob, g_repo, &g_oids[i]));
 		cl_assert(g_len[i] == git_blob_rawsize(blob));
-		cl_assert(memcmp(git_blob_rawcontent(blob), g_raw[i], g_len[i]) == 0);
+		cl_assert(memcmp(git_blob_rawcontent(blob), g_raw[i], (size_t)g_len[i]) == 0);
 		git_blob_free(blob);
 	}
 }

tests-clar/object/tree/duplicateentries.c

@@ -42,7 +42,7 @@ static void tree_checker(
 	git_oid oid;
 
 	cl_git_pass(git_tree_lookup(&tree, _repo, tid));
-	cl_assert_equal_i(1, git_tree_entrycount(tree));
+	cl_assert_equal_i(1, (int)git_tree_entrycount(tree));
 	entry = git_tree_entry_byindex(tree, 0);
 
 	cl_git_pass(git_oid_fromstr(&oid, expected_sha));

tests-clar/refs/reflog/drop.c

@@ -4,15 +4,15 @@
 
 static git_repository *g_repo;
 static git_reflog *g_reflog;
-static unsigned int entrycount;
+static size_t entrycount;
 
 void test_refs_reflog_drop__initialize(void)
 {
 	git_reference *ref;
-	
+
 	g_repo = cl_git_sandbox_init("testrepo.git");
 	cl_git_pass(git_reference_lookup(&ref, g_repo, "HEAD"));
-	
+
 	git_reflog_read(&g_reflog, ref);
 	entrycount = git_reflog_entrycount(g_reflog);
 
@@ -31,7 +31,7 @@ void test_refs_reflog_drop__dropping_a_non_exisiting_entry_from_the_log_returns_
 {
 	cl_assert_equal_i(GIT_ENOTFOUND, git_reflog_drop(g_reflog, entrycount, 0));
 
-	cl_assert_equal_i(entrycount, git_reflog_entrycount(g_reflog));
+	cl_assert_equal_sz(entrycount, git_reflog_entrycount(g_reflog));
 }
 
 void test_refs_reflog_drop__can_drop_an_entry(void)
@@ -39,7 +39,7 @@ void test_refs_reflog_drop__can_drop_an_entry(void)
 	cl_assert(entrycount > 4);
 
 	cl_git_pass(git_reflog_drop(g_reflog, 2, 0));
-	cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog));
+	cl_assert_equal_sz(entrycount - 1, git_reflog_entrycount(g_reflog));
 }
 
 void test_refs_reflog_drop__can_drop_an_entry_and_rewrite_the_log_history(void)
@@ -57,7 +57,7 @@ void test_refs_reflog_drop__can_drop_an_entry_and_rewrite_the_log_history(void)
 
 	cl_git_pass(git_reflog_drop(g_reflog, 1, 1));
 
-	cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog));
+	cl_assert_equal_sz(entrycount - 1, git_reflog_entrycount(g_reflog));
 
 	after_current = git_reflog_entry_byindex(g_reflog, 0);
 
@@ -72,7 +72,7 @@ void test_refs_reflog_drop__can_drop_the_oldest_entry(void)
 	cl_assert(entrycount > 2);
 
 	cl_git_pass(git_reflog_drop(g_reflog, entrycount - 1, 0));
-	cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog));
+	cl_assert_equal_sz(entrycount - 1, git_reflog_entrycount(g_reflog));
 
 	entry = git_reflog_entry_byindex(g_reflog, entrycount - 2);
 	cl_assert(git_oid_streq(&entry->oid_old, GIT_OID_HEX_ZERO) != 0);
@@ -85,7 +85,7 @@ void test_refs_reflog_drop__can_drop_the_oldest_entry_and_rewrite_the_log_histor
 	cl_assert(entrycount > 2);
 
 	cl_git_pass(git_reflog_drop(g_reflog, entrycount - 1, 1));
-	cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog));
+	cl_assert_equal_sz(entrycount - 1, git_reflog_entrycount(g_reflog));
 
 	entry = git_reflog_entry_byindex(g_reflog, entrycount - 2);
 	cl_assert(git_oid_streq(&entry->oid_old, GIT_OID_HEX_ZERO) == 0);
@@ -101,7 +101,7 @@ void test_refs_reflog_drop__can_drop_all_the_entries(void)
 
 	cl_git_pass(git_reflog_drop(g_reflog, 0, 1));
 
-	cl_assert_equal_i(0, git_reflog_entrycount(g_reflog));
+	cl_assert_equal_i(0, (int)git_reflog_entrycount(g_reflog));
 }
 
 void test_refs_reflog_drop__can_persist_deletion_on_disk(void)
@@ -112,7 +112,7 @@ void test_refs_reflog_drop__can_persist_deletion_on_disk(void)
 
 	cl_git_pass(git_reference_lookup(&ref, g_repo, g_reflog->ref_name));
 	cl_git_pass(git_reflog_drop(g_reflog, 0, 1));
-	cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog));
+	cl_assert_equal_sz(entrycount - 1, git_reflog_entrycount(g_reflog));
 	cl_git_pass(git_reflog_write(g_reflog));
 
 	git_reflog_free(g_reflog);
@@ -120,5 +120,5 @@ void test_refs_reflog_drop__can_persist_deletion_on_disk(void)
 	git_reflog_read(&g_reflog, ref);
 	git_reference_free(ref);
 
-	cl_assert_equal_i(entrycount - 1, git_reflog_entrycount(g_reflog));
+	cl_assert_equal_sz(entrycount - 1, git_reflog_entrycount(g_reflog));
 }

tests-clar/refs/reflog/reflog.c

@@ -66,7 +66,7 @@ void test_refs_reflog_reflog__append_then_read(void)
 
 	/* Read and parse the reflog for this branch */
 	cl_git_pass(git_reflog_read(&reflog, lookedup_ref));
-	cl_assert_equal_i(2, git_reflog_entrycount(reflog));
+	cl_assert_equal_i(2, (int)git_reflog_entrycount(reflog));
 
 	entry = git_reflog_entry_byindex(reflog, 1);
 	assert_signature(committer, entry->committer);
@@ -143,7 +143,7 @@ void test_refs_reflog_reflog__reading_the_reflog_from_a_reference_with_no_log_re
 
 	cl_git_pass(git_reflog_read(&reflog, subtrees));
 
-	cl_assert_equal_i(0, git_reflog_entrycount(reflog));
+	cl_assert_equal_i(0, (int)git_reflog_entrycount(reflog));
 
 	git_reflog_free(reflog);
 	git_reference_free(subtrees);
@@ -160,7 +160,7 @@ void test_refs_reflog_reflog__cannot_write_a_moved_reflog(void)
 	cl_git_pass(git_reflog_read(&reflog, master));
 
 	cl_git_pass(git_reflog_write(reflog));
-	
+
 	cl_git_pass(git_reference_rename(master, "refs/moved", 0));
 
 	cl_git_fail(git_reflog_write(reflog));

tests-clar/stash/drop.c

@@ -91,13 +91,13 @@ void test_stash_drop__dropping_an_entry_rewrites_reflog_history(void)
 	push_three_states();
 
 	cl_git_pass(git_reference_lookup(&stash, repo, "refs/stash"));
-	
+
 	cl_git_pass(git_reflog_read(&reflog, stash));
 	entry = git_reflog_entry_byindex(reflog, 1);
 
 	git_oid_cpy(&oid, git_reflog_entry_id_old(entry));
 	count = git_reflog_entrycount(reflog);
-	
+
 	git_reflog_free(reflog);
 
 	cl_git_pass(git_stash_drop(repo, 1));
@@ -106,7 +106,7 @@ void test_stash_drop__dropping_an_entry_rewrites_reflog_history(void)
 	entry = git_reflog_entry_byindex(reflog, 0);
 
 	cl_assert_equal_i(0, git_oid_cmp(&oid, git_reflog_entry_id_old(entry)));
-	cl_assert_equal_i(count - 1, git_reflog_entrycount(reflog));
+	cl_assert_equal_sz(count - 1, git_reflog_entrycount(reflog));
 
 	git_reflog_free(reflog);
 

tests-clar/status/worktree.c

@@ -464,7 +464,7 @@ void test_status_worktree__status_file_without_index_or_workdir(void)
 	cl_git_pass(git_repository_set_workdir(repo, "wd", false));
 
 	cl_git_pass(git_index_open(&index, "empty-index"));
-	cl_assert_equal_i(0, git_index_entrycount(index));
+	cl_assert_equal_i(0, (int)git_index_entrycount(index));
 	git_repository_set_index(repo, index);
 
 	cl_git_pass(git_status_file(&status, repo, "branch_file.txt"));