chore(3p/git): Unvendor git and track patches instead r/2903

This was vendored a long time ago under the expectation that keeping
it in sync with cgit would be easier this way, but it has proven not
to be a big issue.

On the other hand, a vendored copy of git is an annoying maintenance
burden. It is much easier to rebase the single (dottime) patch that we
have.

This removes the vendored copy of git and instead passes the git
source code to cgit via `pkgs.srcOnly`, which includes the applied
patch so that cgit can continue rendering dottime.

Change-Id: If31f62dea7ce688fd1b9050204e9378019775f2b

1 files changed, 0 insertions, 577 deletions

diff --git a/third_party/git/builtin/diff.c b/third_party/git/builtin/diff.c
deleted file mode 100644
index cd4083fed9..0000000000
--- a/third_party/git/builtin/diff.c
+++ /dev/null
@@ -1,577 +0,0 @@
-/*
- * Builtin "git diff"
- *
- * Copyright (c) 2006 Junio C Hamano
- */
-#define USE_THE_INDEX_COMPATIBILITY_MACROS
-#include "cache.h"
-#include "config.h"
-#include "ewah/ewok.h"
-#include "lockfile.h"
-#include "color.h"
-#include "commit.h"
-#include "blob.h"
-#include "tag.h"
-#include "diff.h"
-#include "diffcore.h"
-#include "revision.h"
-#include "log-tree.h"
-#include "builtin.h"
-#include "submodule.h"
-#include "oid-array.h"
-
-#define DIFF_NO_INDEX_EXPLICIT 1
-#define DIFF_NO_INDEX_IMPLICIT 2
-
-static const char builtin_diff_usage[] =
-"git diff [<options>] [<commit>] [--] [<path>...]\n"
-"   or: git diff [<options>] --cached [<commit>] [--] [<path>...]\n"
-"   or: git diff [<options>] <commit> [<commit>...] <commit> [--] [<path>...]\n"
-"   or: git diff [<options>] <commit>...<commit>] [--] [<path>...]\n"
-"   or: git diff [<options>] <blob> <blob>]\n"
-"   or: git diff [<options>] --no-index [--] <path> <path>]\n"
-COMMON_DIFF_OPTIONS_HELP;
-
-static const char *blob_path(struct object_array_entry *entry)
-{
-	return entry->path ? entry->path : entry->name;
-}
-
-static void stuff_change(struct diff_options *opt,
-			 unsigned old_mode, unsigned new_mode,
-			 const struct object_id *old_oid,
-			 const struct object_id *new_oid,
-			 int old_oid_valid,
-			 int new_oid_valid,
-			 const char *old_path,
-			 const char *new_path)
-{
-	struct diff_filespec *one, *two;
-
-	if (!is_null_oid(old_oid) && !is_null_oid(new_oid) &&
-	    oideq(old_oid, new_oid) && (old_mode == new_mode))
-		return;
-
-	if (opt->flags.reverse_diff) {
-		SWAP(old_mode, new_mode);
-		SWAP(old_oid, new_oid);
-		SWAP(old_path, new_path);
-	}
-
-	if (opt->prefix &&
-	    (strncmp(old_path, opt->prefix, opt->prefix_length) ||
-	     strncmp(new_path, opt->prefix, opt->prefix_length)))
-		return;
-
-	one = alloc_filespec(old_path);
-	two = alloc_filespec(new_path);
-	fill_filespec(one, old_oid, old_oid_valid, old_mode);
-	fill_filespec(two, new_oid, new_oid_valid, new_mode);
-
-	diff_queue(&diff_queued_diff, one, two);
-}
-
-static int builtin_diff_b_f(struct rev_info *revs,
-			    int argc, const char **argv,
-			    struct object_array_entry **blob)
-{
-	/* Blob vs file in the working tree*/
-	struct stat st;
-	const char *path;
-
-	if (argc > 1)
-		usage(builtin_diff_usage);
-
-	GUARD_PATHSPEC(&revs->prune_data, PATHSPEC_FROMTOP | PATHSPEC_LITERAL);
-	path = revs->prune_data.items[0].match;
-
-	if (lstat(path, &st))
-		die_errno(_("failed to stat '%s'"), path);
-	if (!(S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)))
-		die(_("'%s': not a regular file or symlink"), path);
-
-	diff_set_mnemonic_prefix(&revs->diffopt, "o/", "w/");
-
-	if (blob[0]->mode == S_IFINVALID)
-		blob[0]->mode = canon_mode(st.st_mode);
-
-	stuff_change(&revs->diffopt,
-		     blob[0]->mode, canon_mode(st.st_mode),
-		     &blob[0]->item->oid, &null_oid,
-		     1, 0,
-		     blob[0]->path ? blob[0]->path : path,
-		     path);
-	diffcore_std(&revs->diffopt);
-	diff_flush(&revs->diffopt);
-	return 0;
-}
-
-static int builtin_diff_blobs(struct rev_info *revs,
-			      int argc, const char **argv,
-			      struct object_array_entry **blob)
-{
-	const unsigned mode = canon_mode(S_IFREG | 0644);
-
-	if (argc > 1)
-		usage(builtin_diff_usage);
-
-	if (blob[0]->mode == S_IFINVALID)
-		blob[0]->mode = mode;
-
-	if (blob[1]->mode == S_IFINVALID)
-		blob[1]->mode = mode;
-
-	stuff_change(&revs->diffopt,
-		     blob[0]->mode, blob[1]->mode,
-		     &blob[0]->item->oid, &blob[1]->item->oid,
-		     1, 1,
-		     blob_path(blob[0]), blob_path(blob[1]));
-	diffcore_std(&revs->diffopt);
-	diff_flush(&revs->diffopt);
-	return 0;
-}
-
-static int builtin_diff_index(struct rev_info *revs,
-			      int argc, const char **argv)
-{
-	int cached = 0;
-	while (1 < argc) {
-		const char *arg = argv[1];
-		if (!strcmp(arg, "--cached") || !strcmp(arg, "--staged"))
-			cached = 1;
-		else
-			usage(builtin_diff_usage);
-		argv++; argc--;
-	}
-	/*
-	 * Make sure there is one revision (i.e. pending object),
-	 * and there is no revision filtering parameters.
-	 */
-	if (revs->pending.nr != 1 ||
-	    revs->max_count != -1 || revs->min_age != -1 ||
-	    revs->max_age != -1)
-		usage(builtin_diff_usage);
-	if (!cached) {
-		setup_work_tree();
-		if (read_cache_preload(&revs->diffopt.pathspec) < 0) {
-			perror("read_cache_preload");
-			return -1;
-		}
-	} else if (read_cache() < 0) {
-		perror("read_cache");
-		return -1;
-	}
-	return run_diff_index(revs, cached);
-}
-
-static int builtin_diff_tree(struct rev_info *revs,
-			     int argc, const char **argv,
-			     struct object_array_entry *ent0,
-			     struct object_array_entry *ent1)
-{
-	const struct object_id *(oid[2]);
-	int swap = 0;
-
-	if (argc > 1)
-		usage(builtin_diff_usage);
-
-	/*
-	 * We saw two trees, ent0 and ent1.  If ent1 is uninteresting,
-	 * swap them.
-	 */
-	if (ent1->item->flags & UNINTERESTING)
-		swap = 1;
-	oid[swap] = &ent0->item->oid;
-	oid[1 - swap] = &ent1->item->oid;
-	diff_tree_oid(oid[0], oid[1], "", &revs->diffopt);
-	log_tree_diff_flush(revs);
-	return 0;
-}
-
-static int builtin_diff_combined(struct rev_info *revs,
-				 int argc, const char **argv,
-				 struct object_array_entry *ent,
-				 int ents)
-{
-	struct oid_array parents = OID_ARRAY_INIT;
-	int i;
-
-	if (argc > 1)
-		usage(builtin_diff_usage);
-
-	if (!revs->dense_combined_merges && !revs->combine_merges)
-		revs->dense_combined_merges = revs->combine_merges = 1;
-	for (i = 1; i < ents; i++)
-		oid_array_append(&parents, &ent[i].item->oid);
-	diff_tree_combined(&ent[0].item->oid, &parents, revs);
-	oid_array_clear(&parents);
-	return 0;
-}
-
-static void refresh_index_quietly(void)
-{
-	struct lock_file lock_file = LOCK_INIT;
-	int fd;
-
-	fd = hold_locked_index(&lock_file, 0);
-	if (fd < 0)
-		return;
-	discard_cache();
-	read_cache();
-	refresh_cache(REFRESH_QUIET|REFRESH_UNMERGED);
-	repo_update_index_if_able(the_repository, &lock_file);
-}
-
-static int builtin_diff_files(struct rev_info *revs, int argc, const char **argv)
-{
-	unsigned int options = 0;
-
-	while (1 < argc && argv[1][0] == '-') {
-		if (!strcmp(argv[1], "--base"))
-			revs->max_count = 1;
-		else if (!strcmp(argv[1], "--ours"))
-			revs->max_count = 2;
-		else if (!strcmp(argv[1], "--theirs"))
-			revs->max_count = 3;
-		else if (!strcmp(argv[1], "-q"))
-			options |= DIFF_SILENT_ON_REMOVED;
-		else if (!strcmp(argv[1], "-h"))
-			usage(builtin_diff_usage);
-		else
-			return error(_("invalid option: %s"), argv[1]);
-		argv++; argc--;
-	}
-
-	/*
-	 * "diff --base" should not combine merges because it was not
-	 * asked to.  "diff -c" should not densify (if the user wants
-	 * dense one, --cc can be explicitly asked for, or just rely
-	 * on the default).
-	 */
-	if (revs->max_count == -1 && !revs->combine_merges &&
-	    (revs->diffopt.output_format & DIFF_FORMAT_PATCH))
-		revs->combine_merges = revs->dense_combined_merges = 1;
-
-	setup_work_tree();
-	if (read_cache_preload(&revs->diffopt.pathspec) < 0) {
-		perror("read_cache_preload");
-		return -1;
-	}
-	return run_diff_files(revs, options);
-}
-
-struct symdiff {
-	struct bitmap *skip;
-	int warn;
-	const char *base, *left, *right;
-};
-
-/*
- * Check for symmetric-difference arguments, and if present, arrange
- * everything we need to know to handle them correctly.  As a bonus,
- * weed out all bogus range-based revision specifications, e.g.,
- * "git diff A..B C..D" or "git diff A..B C" get rejected.
- *
- * For an actual symmetric diff, *symdiff is set this way:
- *
- *  - its skip is non-NULL and marks *all* rev->pending.objects[i]
- *    indices that the caller should ignore (extra merge bases, of
- *    which there might be many, and A in A...B).  Note that the
- *    chosen merge base and right side are NOT marked.
- *  - warn is set if there are multiple merge bases.
- *  - base, left, and right point to the names to use in a
- *    warning about multiple merge bases.
- *
- * If there is no symmetric diff argument, sym->skip is NULL and
- * sym->warn is cleared.  The remaining fields are not set.
- */
-static void symdiff_prepare(struct rev_info *rev, struct symdiff *sym)
-{
-	int i, is_symdiff = 0, basecount = 0, othercount = 0;
-	int lpos = -1, rpos = -1, basepos = -1;
-	struct bitmap *map = NULL;
-
-	/*
-	 * Use the whence fields to find merge bases and left and
-	 * right parts of symmetric difference, so that we do not
-	 * depend on the order that revisions are parsed.  If there
-	 * are any revs that aren't from these sources, we have a
-	 * "git diff C A...B" or "git diff A...B C" case.  Or we
-	 * could even get "git diff A...B C...E", for instance.
-	 *
-	 * If we don't have just one merge base, we pick one
-	 * at random.
-	 *
-	 * NB: REV_CMD_LEFT, REV_CMD_RIGHT are also used for A..B,
-	 * so we must check for SYMMETRIC_LEFT too.  The two arrays
-	 * rev->pending.objects and rev->cmdline.rev are parallel.
-	 */
-	for (i = 0; i < rev->cmdline.nr; i++) {
-		struct object *obj = rev->pending.objects[i].item;
-		switch (rev->cmdline.rev[i].whence) {
-		case REV_CMD_MERGE_BASE:
-			if (basepos < 0)
-				basepos = i;
-			basecount++;
-			break;		/* do mark all bases */
-		case REV_CMD_LEFT:
-			if (lpos >= 0)
-				usage(builtin_diff_usage);
-			lpos = i;
-			if (obj->flags & SYMMETRIC_LEFT) {
-				is_symdiff = 1;
-				break;	/* do mark A */
-			}
-			continue;
-		case REV_CMD_RIGHT:
-			if (rpos >= 0)
-				usage(builtin_diff_usage);
-			rpos = i;
-			continue;	/* don't mark B */
-		case REV_CMD_PARENTS_ONLY:
-		case REV_CMD_REF:
-		case REV_CMD_REV:
-			othercount++;
-			continue;
-		}
-		if (map == NULL)
-			map = bitmap_new();
-		bitmap_set(map, i);
-	}
-
-	/*
-	 * Forbid any additional revs for both A...B and A..B.
-	 */
-	if (lpos >= 0 && othercount > 0)
-		usage(builtin_diff_usage);
-
-	if (!is_symdiff) {
-		bitmap_free(map);
-		sym->warn = 0;
-		sym->skip = NULL;
-		return;
-	}
-
-	sym->left = rev->pending.objects[lpos].name;
-	sym->right = rev->pending.objects[rpos].name;
-	if (basecount == 0)
-		die(_("%s...%s: no merge base"), sym->left, sym->right);
-	sym->base = rev->pending.objects[basepos].name;
-	bitmap_unset(map, basepos);	/* unmark the base we want */
-	sym->warn = basecount > 1;
-	sym->skip = map;
-}
-
-int cmd_diff(int argc, const char **argv, const char *prefix)
-{
-	int i;
-	struct rev_info rev;
-	struct object_array ent = OBJECT_ARRAY_INIT;
-	int blobs = 0, paths = 0;
-	struct object_array_entry *blob[2];
-	int nongit = 0, no_index = 0;
-	int result = 0;
-	struct symdiff sdiff;
-
-	/*
-	 * We could get N tree-ish in the rev.pending_objects list.
-	 * Also there could be M blobs there, and P pathspecs. --cached may
-	 * also be present.
-	 *
-	 * N=0, M=0:
-	 *      cache vs files (diff-files)
-	 *
-	 * N=0, M=0, --cached:
-	 *      HEAD vs cache (diff-index --cached)
-	 *
-	 * N=0, M=2:
-	 *      compare two random blobs.  P must be zero.
-	 *
-	 * N=0, M=1, P=1:
-	 *      compare a blob with a working tree file.
-	 *
-	 * N=1, M=0:
-	 *      tree vs files (diff-index)
-	 *
-	 * N=1, M=0, --cached:
-	 *      tree vs cache (diff-index --cached)
-	 *
-	 * N=2, M=0:
-	 *      tree vs tree (diff-tree)
-	 *
-	 * N=0, M=0, P=2:
-	 *      compare two filesystem entities (aka --no-index).
-	 *
-	 * Other cases are errors.
-	 */
-
-	/* Were we asked to do --no-index explicitly? */
-	for (i = 1; i < argc; i++) {
-		if (!strcmp(argv[i], "--")) {
-			i++;
-			break;
-		}
-		if (!strcmp(argv[i], "--no-index"))
-			no_index = DIFF_NO_INDEX_EXPLICIT;
-		if (argv[i][0] != '-')
-			break;
-	}
-
-	prefix = setup_git_directory_gently(&nongit);
-
-	if (!no_index) {
-		/*
-		 * Treat git diff with at least one path outside of the
-		 * repo the same as if the command would have been executed
-		 * outside of a git repository.  In this case it behaves
-		 * the same way as "git diff --no-index <a> <b>", which acts
-		 * as a colourful "diff" replacement.
-		 */
-		if (nongit || ((argc == i + 2) &&
-			       (!path_inside_repo(prefix, argv[i]) ||
-				!path_inside_repo(prefix, argv[i + 1]))))
-			no_index = DIFF_NO_INDEX_IMPLICIT;
-	}
-
-	init_diff_ui_defaults();
-	git_config(git_diff_ui_config, NULL);
-	precompose_argv(argc, argv);
-
-	repo_init_revisions(the_repository, &rev, prefix);
-
-	/* Set up defaults that will apply to both no-index and regular diffs. */
-	rev.diffopt.stat_width = -1;
-	rev.diffopt.stat_graph_width = -1;
-	rev.diffopt.flags.allow_external = 1;
-	rev.diffopt.flags.allow_textconv = 1;
-
-	/* If this is a no-index diff, just run it and exit there. */
-	if (no_index)
-		exit(diff_no_index(&rev, no_index == DIFF_NO_INDEX_IMPLICIT,
-				   argc, argv));
-
-
-	/*
-	 * Otherwise, we are doing the usual "git" diff; set up any
-	 * further defaults that apply to regular diffs.
-	 */
-	rev.diffopt.skip_stat_unmatch = !!diff_auto_refresh_index;
-
-	/*
-	 * Default to intent-to-add entries invisible in the
-	 * index. This makes them show up as new files in diff-files
-	 * and not at all in diff-cached.
-	 */
-	rev.diffopt.ita_invisible_in_index = 1;
-
-	if (nongit)
-		die(_("Not a git repository"));
-	argc = setup_revisions(argc, argv, &rev, NULL);
-	if (!rev.diffopt.output_format) {
-		rev.diffopt.output_format = DIFF_FORMAT_PATCH;
-		diff_setup_done(&rev.diffopt);
-	}
-
-	rev.diffopt.flags.recursive = 1;
-
-	setup_diff_pager(&rev.diffopt);
-
-	/*
-	 * Do we have --cached and not have a pending object, then
-	 * default to HEAD by hand.  Eek.
-	 */
-	if (!rev.pending.nr) {
-		int i;
-		for (i = 1; i < argc; i++) {
-			const char *arg = argv[i];
-			if (!strcmp(arg, "--"))
-				break;
-			else if (!strcmp(arg, "--cached") ||
-				 !strcmp(arg, "--staged")) {
-				add_head_to_pending(&rev);
-				if (!rev.pending.nr) {
-					struct tree *tree;
-					tree = lookup_tree(the_repository,
-							   the_repository->hash_algo->empty_tree);
-					add_pending_object(&rev, &tree->object, "HEAD");
-				}
-				break;
-			}
-		}
-	}
-
-	symdiff_prepare(&rev, &sdiff);
-	for (i = 0; i < rev.pending.nr; i++) {
-		struct object_array_entry *entry = &rev.pending.objects[i];
-		struct object *obj = entry->item;
-		const char *name = entry->name;
-		int flags = (obj->flags & UNINTERESTING);
-		if (!obj->parsed)
-			obj = parse_object(the_repository, &obj->oid);
-		obj = deref_tag(the_repository, obj, NULL, 0);
-		if (!obj)
-			die(_("invalid object '%s' given."), name);
-		if (obj->type == OBJ_COMMIT)
-			obj = &get_commit_tree(((struct commit *)obj))->object;
-
-		if (obj->type == OBJ_TREE) {
-			if (sdiff.skip && bitmap_get(sdiff.skip, i))
-				continue;
-			obj->flags |= flags;
-			add_object_array(obj, name, &ent);
-		} else if (obj->type == OBJ_BLOB) {
-			if (2 <= blobs)
-				die(_("more than two blobs given: '%s'"), name);
-			blob[blobs] = entry;
-			blobs++;
-
-		} else {
-			die(_("unhandled object '%s' given."), name);
-		}
-	}
-	if (rev.prune_data.nr)
-		paths += rev.prune_data.nr;
-
-	/*
-	 * Now, do the arguments look reasonable?
-	 */
-	if (!ent.nr) {
-		switch (blobs) {
-		case 0:
-			result = builtin_diff_files(&rev, argc, argv);
-			break;
-		case 1:
-			if (paths != 1)
-				usage(builtin_diff_usage);
-			result = builtin_diff_b_f(&rev, argc, argv, blob);
-			break;
-		case 2:
-			if (paths)
-				usage(builtin_diff_usage);
-			result = builtin_diff_blobs(&rev, argc, argv, blob);
-			break;
-		default:
-			usage(builtin_diff_usage);
-		}
-	}
-	else if (blobs)
-		usage(builtin_diff_usage);
-	else if (ent.nr == 1)
-		result = builtin_diff_index(&rev, argc, argv);
-	else if (ent.nr == 2) {
-		if (sdiff.warn)
-			warning(_("%s...%s: multiple merge bases, using %s"),
-				sdiff.left, sdiff.right, sdiff.base);
-		result = builtin_diff_tree(&rev, argc, argv,
-					   &ent.objects[0], &ent.objects[1]);
-	} else
-		result = builtin_diff_combined(&rev, argc, argv,
-					       ent.objects, ent.nr);
-	result = diff_result_code(&rev.diffopt, result);
-	if (1 < rev.diffopt.skip_stat_unmatch)
-		refresh_index_quietly();
-	UNLEAK(rev);
-	UNLEAK(ent);
-	UNLEAK(blob);
-	return result;
-}