[thirdparty/git.git] / diff-lib.c

/*
 * Copyright (C) 2005 Junio C Hamano
 */
#include "cache.h"
#include "quote.h"
#include "commit.h"
#include "diff.h"
#include "diffcore.h"
#include "revision.h"
#include "cache-tree.h"
#include "path-list.h"

/*
 * diff-files
 */

static int read_directory(const char *path, struct path_list *list)
{
	DIR *dir;
	struct dirent *e;

	if (!(dir = opendir(path)))
		return error("Could not open directory %s", path);

	while ((e = readdir(dir)))
		if (strcmp(".", e->d_name) && strcmp("..", e->d_name))
			path_list_insert(xstrdup(e->d_name), list);

	closedir(dir);
	return 0;
}

static int get_mode(const char *path, int *mode)
{
	struct stat st;

	if (!path || !strcmp(path, "/dev/null"))
		*mode = 0;
	else if (!strcmp(path, "-"))
		*mode = ntohl(create_ce_mode(0666));
	else if (stat(path, &st))
		return error("Could not access '%s'", path);
	else
		*mode = st.st_mode;
	return 0;
}

static int queue_diff(struct diff_options *o,
		const char *name1, const char *name2)
{
	int mode1 = 0, mode2 = 0;

	if (get_mode(name1, &mode1) || get_mode(name2, &mode2))
		return -1;

	if (mode1 && mode2 && S_ISDIR(mode1) != S_ISDIR(mode2))
		return error("file/directory conflict: %s, %s", name1, name2);

	if (S_ISDIR(mode1) || S_ISDIR(mode2)) {
		char buffer1[PATH_MAX], buffer2[PATH_MAX];
		struct path_list p1 = {NULL, 0, 0, 1}, p2 = {NULL, 0, 0, 1};
		int len1 = 0, len2 = 0, i1, i2, ret = 0;

		if (name1 && read_directory(name1, &p1))
			return -1;
		if (name2 && read_directory(name2, &p2)) {
			path_list_clear(&p1, 0);
			return -1;
		}

		if (name1) {
			len1 = strlen(name1);
			if (len1 > 0 && name1[len1 - 1] == '/')
				len1--;
			memcpy(buffer1, name1, len1);
			buffer1[len1++] = '/';
		}

		if (name2) {
			len2 = strlen(name2);
			if (len2 > 0 && name2[len2 - 1] == '/')
				len2--;
			memcpy(buffer2, name2, len2);
			buffer2[len2++] = '/';
		}

		for (i1 = i2 = 0; !ret && (i1 < p1.nr || i2 < p2.nr); ) {
			const char *n1, *n2;
			int comp;

			if (i1 == p1.nr)
				comp = 1;
			else if (i2 == p2.nr)
				comp = -1;
			else
				comp = strcmp(p1.items[i1].path,
					p2.items[i2].path);

			if (comp > 0)
				n1 = NULL;
			else {
				n1 = buffer1;
				strncpy(buffer1 + len1, p1.items[i1++].path,
						PATH_MAX - len1);
			}

			if (comp < 0)
				n2 = NULL;
			else {
				n2 = buffer2;
				strncpy(buffer2 + len2, p2.items[i2++].path,
						PATH_MAX - len2);
			}

			ret = queue_diff(o, n1, n2);
		}
		path_list_clear(&p1, 0);
		path_list_clear(&p2, 0);

		return ret;
	} else {
		struct diff_filespec *d1, *d2;

		if (o->reverse_diff) {
			unsigned tmp;
			const char *tmp_c;
			tmp = mode1; mode1 = mode2; mode2 = tmp;
			tmp_c = name1; name1 = name2; name2 = tmp_c;
		}

		if (!name1)
			name1 = "/dev/null";
		if (!name2)
			name2 = "/dev/null";
		d1 = alloc_filespec(name1);
		d2 = alloc_filespec(name2);
		fill_filespec(d1, null_sha1, mode1);
		fill_filespec(d2, null_sha1, mode2);

		diff_queue(&diff_queued_diff, d1, d2);
		return 0;
	}
}

/*
 * Does the path name a blob in the working tree, or a directory
 * in the working tree?
 */
static int is_in_index(const char *path)
{
	int len, pos;
	struct cache_entry *ce;

	len = strlen(path);
	while (path[len-1] == '/')
		len--;
	if (!len)
		return 1; /* "." */
	pos = cache_name_pos(path, len);
	if (0 <= pos)
		return 1;
	pos = -1 - pos;
	while (pos < active_nr) {
		ce = active_cache[pos++];
		if (ce_namelen(ce) <= len ||
		    strncmp(ce->name, path, len) ||
		    (ce->name[len] > '/'))
			break; /* path cannot be a prefix */
		if (ce->name[len] == '/')
			return 1;
	}
	return 0;
}

static int handle_diff_files_args(struct rev_info *revs,
		int argc, const char **argv, int *silent)
{
	*silent = 0;

	/* revs->max_count == -2 means --no-index */
	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], "-n") ||
				!strcmp(argv[1], "--no-index")) {
			revs->max_count = -2;
			revs->diffopt.exit_with_status = 1;
		}
		else if (!strcmp(argv[1], "-q"))
			*silent = 1;
		else
			return error("invalid option: %s", argv[1]);
		argv++; argc--;
	}

	if (revs->max_count == -1 && revs->diffopt.nr_paths == 2) {
		/*
		 * If two files are specified, and at least one is untracked,
		 * default to no-index.
		 */
		read_cache();
		if (!is_in_index(revs->diffopt.paths[0]) ||
					!is_in_index(revs->diffopt.paths[1]))
			revs->max_count = -2;
	}

	/*
	 * Make sure there are NO revision (i.e. pending object) parameter,
	 * rev.max_count is reasonable (0 <= n <= 3),
	 * there is no other revision filtering parameters.
	 */
	if (revs->pending.nr || revs->max_count > 3 ||
	    revs->min_age != -1 || revs->max_age != -1)
		return error("no revision allowed with diff-files");

	if (revs->max_count == -1 &&
	    (revs->diffopt.output_format & DIFF_FORMAT_PATCH))
		revs->combine_merges = revs->dense_combined_merges = 1;

	return 0;
}

static int is_outside_repo(const char *path, int nongit, const char *prefix)
{
	int i;
	if (nongit || !strcmp(path, "-") || path[0] == '/')
		return 1;
	if (prefixcmp(path, "../"))
		return 0;
	if (!prefix)
		return 1;
	for (i = strlen(prefix); !prefixcmp(path, "../"); ) {
		while (i > 0 && prefix[i - 1] != '/')
			i--;
		if (--i < 0)
			return 1;
		path += 3;
	}
	return 0;
}

int setup_diff_no_index(struct rev_info *revs,
		int argc, const char ** argv, int nongit, const char *prefix)
{
	int i;
	for (i = 1; i < argc; i++)
		if (argv[i][0] != '-' || argv[i][1] == '\0')
			break;
		else if (!strcmp(argv[i], "--")) {
			i++;
			break;
		} else if (i < argc - 3 && !strcmp(argv[i], "--no-index")) {
			i = argc - 3;
			revs->diffopt.exit_with_status = 1;
			break;
		}
	if (argc != i + 2 || (!is_outside_repo(argv[i + 1], nongit, prefix) &&
				!is_outside_repo(argv[i], nongit, prefix)))
		return -1;

	diff_setup(&revs->diffopt);
	for (i = 1; i < argc - 2; )
		if (!strcmp(argv[i], "--no-index"))
			i++;
		else {
			int j = diff_opt_parse(&revs->diffopt,
					argv + i, argc - i);
			if (!j)
				die("invalid diff option/value: %s", argv[i]);
			i += j;
		}

	if (prefix) {
		int len = strlen(prefix);

		revs->diffopt.paths = xcalloc(2, sizeof(char*));
		for (i = 0; i < 2; i++) {
			const char *p = argv[argc - 2 + i];
			/*
			 * stdin should be spelled as '-'; if you have
			 * path that is '-', spell it as ./-.
			 */
			p = (strcmp(p, "-")
			     ? xstrdup(prefix_filename(prefix, len, p))
			     : p);
			revs->diffopt.paths[i] = p;
		}
	}
	else
		revs->diffopt.paths = argv + argc - 2;
	revs->diffopt.nr_paths = 2;
	revs->max_count = -2;
	return 0;
}

int run_diff_files_cmd(struct rev_info *revs, int argc, const char **argv)
{
	int silent_on_removed;

	if (handle_diff_files_args(revs, argc, argv, &silent_on_removed))
		return -1;

	if (revs->max_count == -2) {
		if (revs->diffopt.nr_paths != 2)
			return error("need two files/directories with --no-index");
		if (queue_diff(&revs->diffopt, revs->diffopt.paths[0],
				revs->diffopt.paths[1]))
			return -1;
		diffcore_std(&revs->diffopt);
		diff_flush(&revs->diffopt);
		/*
		 * The return code for --no-index imitates diff(1):
		 * 0 = no changes, 1 = changes, else error
		 */
		return revs->diffopt.found_changes;
	}

	if (read_cache() < 0) {
		perror("read_cache");
		return -1;
	}
	return run_diff_files(revs, silent_on_removed);
}

int run_diff_files(struct rev_info *revs, int silent_on_removed)
{
	int entries, i;
	int diff_unmerged_stage = revs->max_count;

	if (diff_unmerged_stage < 0)
		diff_unmerged_stage = 2;
	entries = active_nr;
	for (i = 0; i < entries; i++) {
		struct stat st;
		unsigned int oldmode, newmode;
		struct cache_entry *ce = active_cache[i];
		int changed;

		if (revs->diffopt.quiet && revs->diffopt.has_changes)
			break;

		if (!ce_path_match(ce, revs->prune_data))
			continue;

		if (ce_stage(ce)) {
			struct combine_diff_path *dpath;
			int num_compare_stages = 0;
			size_t path_len;

			path_len = ce_namelen(ce);

			dpath = xmalloc(combine_diff_path_size(5, path_len));
			dpath->path = (char *) &(dpath->parent[5]);

			dpath->next = NULL;
			dpath->len = path_len;
			memcpy(dpath->path, ce->name, path_len);
			dpath->path[path_len] = '\0';
			hashclr(dpath->sha1);
			memset(&(dpath->parent[0]), 0,
			       sizeof(struct combine_diff_parent)*5);

			if (lstat(ce->name, &st) < 0) {
				if (errno != ENOENT && errno != ENOTDIR) {
					perror(ce->name);
					continue;
				}
				if (silent_on_removed)
					continue;
			}
			else
				dpath->mode = canon_mode(st.st_mode);

			while (i < entries) {
				struct cache_entry *nce = active_cache[i];
				int stage;

				if (strcmp(ce->name, nce->name))
					break;

				/* Stage #2 (ours) is the first parent,
				 * stage #3 (theirs) is the second.
				 */
				stage = ce_stage(nce);
				if (2 <= stage) {
					int mode = ntohl(nce->ce_mode);
					num_compare_stages++;
					hashcpy(dpath->parent[stage-2].sha1, nce->sha1);
					dpath->parent[stage-2].mode =
						canon_mode(mode);
					dpath->parent[stage-2].status =
						DIFF_STATUS_MODIFIED;
				}

				/* diff against the proper unmerged stage */
				if (stage == diff_unmerged_stage)
					ce = nce;
				i++;
			}
			/*
			 * Compensate for loop update
			 */
			i--;

			if (revs->combine_merges && num_compare_stages == 2) {
				show_combined_diff(dpath, 2,
						   revs->dense_combined_merges,
						   revs);
				free(dpath);
				continue;
			}
			free(dpath);
			dpath = NULL;

			/*
			 * Show the diff for the 'ce' if we found the one
			 * from the desired stage.
			 */
			diff_unmerge(&revs->diffopt, ce->name, 0, null_sha1);
			if (ce_stage(ce) != diff_unmerged_stage)
				continue;
		}

		if (lstat(ce->name, &st) < 0) {
			if (errno != ENOENT && errno != ENOTDIR) {
				perror(ce->name);
				continue;
			}
			if (silent_on_removed)
				continue;
			diff_addremove(&revs->diffopt, '-', ntohl(ce->ce_mode),
				       ce->sha1, ce->name, NULL);
			continue;
		}
		changed = ce_match_stat(ce, &st, 0);
		if (!changed && !revs->diffopt.find_copies_harder)
			continue;
		oldmode = ntohl(ce->ce_mode);

		newmode = canon_mode(st.st_mode);
		if (!trust_executable_bit &&
		    S_ISREG(newmode) && S_ISREG(oldmode) &&
		    ((newmode ^ oldmode) == 0111))
			newmode = oldmode;
		else if (!has_symlinks &&
		    S_ISREG(newmode) && S_ISLNK(oldmode))
			newmode = oldmode;
		diff_change(&revs->diffopt, oldmode, newmode,
			    ce->sha1, (changed ? null_sha1 : ce->sha1),
			    ce->name, NULL);

	}
	diffcore_std(&revs->diffopt);
	diff_flush(&revs->diffopt);
	return 0;
}

/*
 * diff-index
 */

/* A file entry went away or appeared */
static void diff_index_show_file(struct rev_info *revs,
				 const char *prefix,
				 struct cache_entry *ce,
				 unsigned char *sha1, unsigned int mode)
{
	diff_addremove(&revs->diffopt, prefix[0], ntohl(mode),
		       sha1, ce->name, NULL);
}

static int get_stat_data(struct cache_entry *ce,
			 unsigned char **sha1p,
			 unsigned int *modep,
			 int cached, int match_missing)
{
	unsigned char *sha1 = ce->sha1;
	unsigned int mode = ce->ce_mode;

	if (!cached) {
		static unsigned char no_sha1[20];
		int changed;
		struct stat st;
		if (lstat(ce->name, &st) < 0) {
			if (errno == ENOENT && match_missing) {
				*sha1p = sha1;
				*modep = mode;
				return 0;
			}
			return -1;
		}
		changed = ce_match_stat(ce, &st, 0);
		if (changed) {
			mode = ce_mode_from_stat(ce, st.st_mode);
			sha1 = no_sha1;
		}
	}

	*sha1p = sha1;
	*modep = mode;
	return 0;
}

static void show_new_file(struct rev_info *revs,
			  struct cache_entry *new,
			  int cached, int match_missing)
{
	unsigned char *sha1;
	unsigned int mode;

	/* New file in the index: it might actually be different in
	 * the working copy.
	 */
	if (get_stat_data(new, &sha1, &mode, cached, match_missing) < 0)
		return;

	diff_index_show_file(revs, "+", new, sha1, mode);
}

static int show_modified(struct rev_info *revs,
			 struct cache_entry *old,
			 struct cache_entry *new,
			 int report_missing,
			 int cached, int match_missing)
{
	unsigned int mode, oldmode;
	unsigned char *sha1;

	if (get_stat_data(new, &sha1, &mode, cached, match_missing) < 0) {
		if (report_missing)
			diff_index_show_file(revs, "-", old,
					     old->sha1, old->ce_mode);
		return -1;
	}

	if (revs->combine_merges && !cached &&
	    (hashcmp(sha1, old->sha1) || hashcmp(old->sha1, new->sha1))) {
		struct combine_diff_path *p;
		int pathlen = ce_namelen(new);

		p = xmalloc(combine_diff_path_size(2, pathlen));
		p->path = (char *) &p->parent[2];
		p->next = NULL;
		p->len = pathlen;
		memcpy(p->path, new->name, pathlen);
		p->path[pathlen] = 0;
		p->mode = ntohl(mode);
		hashclr(p->sha1);
		memset(p->parent, 0, 2 * sizeof(struct combine_diff_parent));
		p->parent[0].status = DIFF_STATUS_MODIFIED;
		p->parent[0].mode = ntohl(new->ce_mode);
		hashcpy(p->parent[0].sha1, new->sha1);
		p->parent[1].status = DIFF_STATUS_MODIFIED;
		p->parent[1].mode = ntohl(old->ce_mode);
		hashcpy(p->parent[1].sha1, old->sha1);
		show_combined_diff(p, 2, revs->dense_combined_merges, revs);
		free(p);
		return 0;
	}

	oldmode = old->ce_mode;
	if (mode == oldmode && !hashcmp(sha1, old->sha1) &&
	    !revs->diffopt.find_copies_harder)
		return 0;

	mode = ntohl(mode);
	oldmode = ntohl(oldmode);

	diff_change(&revs->diffopt, oldmode, mode,
		    old->sha1, sha1, old->name, NULL);
	return 0;
}

static int diff_cache(struct rev_info *revs,
		      struct cache_entry **ac, int entries,
		      const char **pathspec,
		      int cached, int match_missing)
{
	while (entries) {
		struct cache_entry *ce = *ac;
		int same = (entries > 1) && ce_same_name(ce, ac[1]);

		if (revs->diffopt.quiet && revs->diffopt.has_changes)
			break;

		if (!ce_path_match(ce, pathspec))
			goto skip_entry;

		switch (ce_stage(ce)) {
		case 0:
			/* No stage 1 entry? That means it's a new file */
			if (!same) {
				show_new_file(revs, ce, cached, match_missing);
				break;
			}
			/* Show difference between old and new */
			show_modified(revs, ac[1], ce, 1,
				      cached, match_missing);
			break;
		case 1:
			/* No stage 3 (merge) entry?
			 * That means it's been deleted.
			 */
			if (!same) {
				diff_index_show_file(revs, "-", ce,
						     ce->sha1, ce->ce_mode);
				break;
			}
			/* We come here with ce pointing at stage 1
			 * (original tree) and ac[1] pointing at stage
			 * 3 (unmerged).  show-modified with
			 * report-missing set to false does not say the
			 * file is deleted but reports true if work
			 * tree does not have it, in which case we
			 * fall through to report the unmerged state.
			 * Otherwise, we show the differences between
			 * the original tree and the work tree.
			 */
			if (!cached &&
			    !show_modified(revs, ce, ac[1], 0,
					   cached, match_missing))
				break;
			diff_unmerge(&revs->diffopt, ce->name,
				     ntohl(ce->ce_mode), ce->sha1);
			break;
		case 3:
			diff_unmerge(&revs->diffopt, ce->name,
				     0, null_sha1);
			break;

		default:
			die("impossible cache entry stage");
		}

skip_entry:
		/*
		 * Ignore all the different stages for this file,
		 * we've handled the relevant cases now.
		 */
		do {
			ac++;
			entries--;
		} while (entries && ce_same_name(ce, ac[0]));
	}
	return 0;
}

/*
 * This turns all merge entries into "stage 3". That guarantees that
 * when we read in the new tree (into "stage 1"), we won't lose sight
 * of the fact that we had unmerged entries.
 */
static void mark_merge_entries(void)
{
	int i;
	for (i = 0; i < active_nr; i++) {
		struct cache_entry *ce = active_cache[i];
		if (!ce_stage(ce))
			continue;
		ce->ce_flags |= htons(CE_STAGEMASK);
	}
}

int run_diff_index(struct rev_info *revs, int cached)
{
	int ret;
	struct object *ent;
	struct tree *tree;
	const char *tree_name;
	int match_missing = 0;

	/* 
	 * Backward compatibility wart - "diff-index -m" does
	 * not mean "do not ignore merges", but totally different.
	 */
	if (!revs->ignore_merges)
		match_missing = 1;

	mark_merge_entries();

	ent = revs->pending.objects[0].item;
	tree_name = revs->pending.objects[0].name;
	tree = parse_tree_indirect(ent->sha1);
	if (!tree)
		return error("bad tree object %s", tree_name);
	if (read_tree(tree, 1, revs->prune_data))
		return error("unable to read tree object %s", tree_name);
	ret = diff_cache(revs, active_cache, active_nr, revs->prune_data,
			 cached, match_missing);
	diffcore_std(&revs->diffopt);
	diff_flush(&revs->diffopt);
	return ret;
}

int do_diff_cache(const unsigned char *tree_sha1, struct diff_options *opt)
{
	struct tree *tree;
	struct rev_info revs;
	int i;
	struct cache_entry **dst;
	struct cache_entry *last = NULL;

	/*
	 * This is used by git-blame to run diff-cache internally;
	 * it potentially needs to repeatedly run this, so we will
	 * start by removing the higher order entries the last round
	 * left behind.
	 */
	dst = active_cache;
	for (i = 0; i < active_nr; i++) {
		struct cache_entry *ce = active_cache[i];
		if (ce_stage(ce)) {
			if (last && !strcmp(ce->name, last->name))
				continue;
			cache_tree_invalidate_path(active_cache_tree,
						   ce->name);
			last = ce;
			ce->ce_mode = 0;
			ce->ce_flags &= ~htons(CE_STAGEMASK);
		}
		*dst++ = ce;
	}
	active_nr = dst - active_cache;

	init_revisions(&revs, NULL);
	revs.prune_data = opt->paths;
	tree = parse_tree_indirect(tree_sha1);
	if (!tree)
		die("bad tree object %s", sha1_to_hex(tree_sha1));
	if (read_tree(tree, 1, opt->paths))
		return error("unable to read tree %s", sha1_to_hex(tree_sha1));
	return diff_cache(&revs, active_cache, active_nr, revs.prune_data,
			  1, 0);
}
Commit	Line	Data
be3cfa85 JH	1	/*
	2	* Copyright (C) 2005 Junio C Hamano
	3	*/
86436c28	4	#include "cache.h"
6fb737be	5	#include "quote.h"
6973dcae	6	#include "commit.h"
86436c28	7	#include "diff.h"
427dcb4b	8	#include "diffcore.h"
6973dcae	9	#include "revision.h"
1cfe7733	10	#include "cache-tree.h"
d516c2d1	11	#include "path-list.h"
427dcb4b	12
b46f0b6d	13	/*
6973dcae	14	* diff-files
b46f0b6d	15	*/
f0c6b2a2	16
d516c2d1 JS	17	static int read_directory(const char path, struct path_list list)
	18	{
	19	DIR *dir;
	20	struct dirent *e;
	21
	22	if (!(dir = opendir(path)))
	23	return error("Could not open directory %s", path);
	24
	25	while ((e = readdir(dir)))
	26	if (strcmp(".", e->d_name) && strcmp("..", e->d_name))
	27	path_list_insert(xstrdup(e->d_name), list);
	28
	29	closedir(dir);
	30	return 0;
	31	}
	32
0c725f1b JS	33	static int get_mode(const char path, int mode)
	34	{
	35	struct stat st;
	36
	37	if (!path \|\| !strcmp(path, "/dev/null"))
	38	*mode = 0;
	39	else if (!strcmp(path, "-"))
	40	*mode = ntohl(create_ce_mode(0666));
	41	else if (stat(path, &st))
	42	return error("Could not access '%s'", path);
	43	else
	44	*mode = st.st_mode;
	45	return 0;
	46	}
	47
d516c2d1 JS	48	static int queue_diff(struct diff_options *o,
	49	const char name1, const char name2)
	50	{
d516c2d1 JS	51	int mode1 = 0, mode2 = 0;
d516c2d1 JS	52
0c725f1b JS	53	if (get_mode(name1, &mode1) \|\| get_mode(name2, &mode2))
0c725f1b JS	54	return -1;
d516c2d1 JS	55
	56	if (mode1 && mode2 && S_ISDIR(mode1) != S_ISDIR(mode2))
	57	return error("file/directory conflict: %s, %s", name1, name2);
	58
	59	if (S_ISDIR(mode1) \|\| S_ISDIR(mode2)) {
	60	char buffer1[PATH_MAX], buffer2[PATH_MAX];
	61	struct path_list p1 = {NULL, 0, 0, 1}, p2 = {NULL, 0, 0, 1};
	62	int len1 = 0, len2 = 0, i1, i2, ret = 0;
	63
	64	if (name1 && read_directory(name1, &p1))
	65	return -1;
	66	if (name2 && read_directory(name2, &p2)) {
	67	path_list_clear(&p1, 0);
	68	return -1;
	69	}
	70
	71	if (name1) {
	72	len1 = strlen(name1);
	73	if (len1 > 0 && name1[len1 - 1] == '/')
	74	len1--;
	75	memcpy(buffer1, name1, len1);
	76	buffer1[len1++] = '/';
	77	}
	78
	79	if (name2) {
	80	len2 = strlen(name2);
	81	if (len2 > 0 && name2[len2 - 1] == '/')
	82	len2--;
	83	memcpy(buffer2, name2, len2);
	84	buffer2[len2++] = '/';
	85	}
	86
	87	for (i1 = i2 = 0; !ret && (i1 < p1.nr \|\| i2 < p2.nr); ) {
	88	const char n1, n2;
	89	int comp;
	90
	91	if (i1 == p1.nr)
	92	comp = 1;
	93	else if (i2 == p2.nr)
	94	comp = -1;
	95	else
	96	comp = strcmp(p1.items[i1].path,
	97	p2.items[i2].path);
	98
	99	if (comp > 0)
	100	n1 = NULL;
	101	else {
	102	n1 = buffer1;
	103	strncpy(buffer1 + len1, p1.items[i1++].path,
	104	PATH_MAX - len1);
	105	}
	106
	107	if (comp < 0)
	108	n2 = NULL;
	109	else {
	110	n2 = buffer2;
	111	strncpy(buffer2 + len2, p2.items[i2++].path,
	112	PATH_MAX - len2);
	113	}
	114
	115	ret = queue_diff(o, n1, n2);
	116	}
	117	path_list_clear(&p1, 0);
	118	path_list_clear(&p2, 0);
119
120	return ret;
121	} else {
122	struct diff_filespec d1, d2;
123
124	if (o->reverse_diff) {
125	unsigned tmp;
126	const char *tmp_c;
127	tmp = mode1; mode1 = mode2; mode2 = tmp;
128	tmp_c = name1; name1 = name2; name2 = tmp_c;
129	}
130
131	if (!name1)
132	name1 = "/dev/null";
133	if (!name2)
134	name2 = "/dev/null";
135	d1 = alloc_filespec(name1);
136	d2 = alloc_filespec(name2);
137	fill_filespec(d1, null_sha1, mode1);
138	fill_filespec(d2, null_sha1, mode2);
139
140	diff_queue(&diff_queued_diff, d1, d2);
141	return 0;
142	}
143	}
144
1ad029b6 JH	145	/*
	146	* Does the path name a blob in the working tree, or a directory
	147	* in the working tree?
	148	*/
d516c2d1 JS	149	static int is_in_index(const char *path)
d516c2d1 JS	150	{
1ad029b6 JH	151	int len, pos;
	152	struct cache_entry *ce;
	153
	154	len = strlen(path);
	155	while (path[len-1] == '/')
	156	len--;
	157	if (!len)
	158	return 1; /* "." */
	159	pos = cache_name_pos(path, len);
	160	if (0 <= pos)
	161	return 1;
	162	pos = -1 - pos;
	163	while (pos < active_nr) {
	164	ce = active_cache[pos++];
	165	if (ce_namelen(ce) <= len \|\|
	166	strncmp(ce->name, path, len) \|\|
	167	(ce->name[len] > '/'))
	168	break; /* path cannot be a prefix */
	169	if (ce->name[len] == '/')
	170	return 1;
	171	}
	172	return 0;
d516c2d1 JS	173	}
	174
	175	static int handle_diff_files_args(struct rev_info *revs,
	176	int argc, const char *argv, int silent)
	177	{
	178	*silent = 0;
	179
	180	/* revs->max_count == -2 means --no-index */
	181	while (1 < argc && argv[1][0] == '-') {
	182	if (!strcmp(argv[1], "--base"))
	183	revs->max_count = 1;
	184	else if (!strcmp(argv[1], "--ours"))
	185	revs->max_count = 2;
	186	else if (!strcmp(argv[1], "--theirs"))
	187	revs->max_count = 3;
	188	else if (!strcmp(argv[1], "-n") \|\|
41bbf9d5	189	!strcmp(argv[1], "--no-index")) {
d516c2d1	190	revs->max_count = -2;
41bbf9d5 AR	191	revs->diffopt.exit_with_status = 1;
41bbf9d5 AR	192	}
d516c2d1 JS	193	else if (!strcmp(argv[1], "-q"))
	194	*silent = 1;
	195	else
	196	return error("invalid option: %s", argv[1]);
	197	argv++; argc--;
	198	}
	199
	200	if (revs->max_count == -1 && revs->diffopt.nr_paths == 2) {
	201	/*
	202	* If two files are specified, and at least one is untracked,
	203	* default to no-index.
	204	*/
	205	read_cache();
	206	if (!is_in_index(revs->diffopt.paths[0]) \|\|
	207	!is_in_index(revs->diffopt.paths[1]))
	208	revs->max_count = -2;
	209	}
	210
	211	/*
	212	* Make sure there are NO revision (i.e. pending object) parameter,
	213	* rev.max_count is reasonable (0 <= n <= 3),
	214	* there is no other revision filtering parameters.
	215	*/
	216	if (revs->pending.nr \|\| revs->max_count > 3 \|\|
	217	revs->min_age != -1 \|\| revs->max_age != -1)
	218	return error("no revision allowed with diff-files");
	219
	220	if (revs->max_count == -1 &&
	221	(revs->diffopt.output_format & DIFF_FORMAT_PATCH))
	222	revs->combine_merges = revs->dense_combined_merges = 1;
	223
	224	return 0;
	225	}
	226
fcfa33ec JS	227	static int is_outside_repo(const char path, int nongit, const char prefix)
	228	{
	229	int i;
	230	if (nongit \|\| !strcmp(path, "-") \|\| path[0] == '/')
	231	return 1;
	232	if (prefixcmp(path, "../"))
	233	return 0;
	234	if (!prefix)
	235	return 1;
	236	for (i = strlen(prefix); !prefixcmp(path, "../"); ) {
	237	while (i > 0 && prefix[i - 1] != '/')
	238	i--;
	239	if (--i < 0)
	240	return 1;
	241	path += 3;
	242	}
	243	return 0;
	244	}
	245
	246	int setup_diff_no_index(struct rev_info *revs,
	247	int argc, const char ** argv, int nongit, const char *prefix)
	248	{
	249	int i;
	250	for (i = 1; i < argc; i++)
5332b2af	251	if (argv[i][0] != '-' \|\| argv[i][1] == '\0')
fcfa33ec JS	252	break;
	253	else if (!strcmp(argv[i], "--")) {
	254	i++;
	255	break;
	256	} else if (i < argc - 3 && !strcmp(argv[i], "--no-index")) {
	257	i = argc - 3;
41bbf9d5	258	revs->diffopt.exit_with_status = 1;
fcfa33ec JS	259	break;
	260	}
	261	if (argc != i + 2 \|\| (!is_outside_repo(argv[i + 1], nongit, prefix) &&
	262	!is_outside_repo(argv[i], nongit, prefix)))
	263	return -1;
	264
	265	diff_setup(&revs->diffopt);
	266	for (i = 1; i < argc - 2; )
	267	if (!strcmp(argv[i], "--no-index"))
	268	i++;
	269	else {
	270	int j = diff_opt_parse(&revs->diffopt,
	271	argv + i, argc - i);
	272	if (!j)
	273	die("invalid diff option/value: %s", argv[i]);
	274	i += j;
	275	}
ae792aa5 JH	276
	277	if (prefix) {
	278	int len = strlen(prefix);
	279
	280	revs->diffopt.paths = xcalloc(2, sizeof(char*));
	281	for (i = 0; i < 2; i++) {
3afaa72d JH	282	const char *p = argv[argc - 2 + i];
	283	/*
	284	* stdin should be spelled as '-'; if you have
	285	* path that is '-', spell it as ./-.
	286	*/
	287	p = (strcmp(p, "-")
	288	? xstrdup(prefix_filename(prefix, len, p))
	289	: p);
	290	revs->diffopt.paths[i] = p;
ae792aa5 JH	291	}
	292	}
	293	else
	294	revs->diffopt.paths = argv + argc - 2;
fcfa33ec JS	295	revs->diffopt.nr_paths = 2;
	296	revs->max_count = -2;
	297	return 0;
	298	}
	299
d516c2d1 JS	300	int run_diff_files_cmd(struct rev_info revs, int argc, const char *argv)
	301	{
	302	int silent_on_removed;
	303
	304	if (handle_diff_files_args(revs, argc, argv, &silent_on_removed))
	305	return -1;
	306
	307	if (revs->max_count == -2) {
	308	if (revs->diffopt.nr_paths != 2)
	309	return error("need two files/directories with --no-index");
34a5e1a2 JS	310	if (queue_diff(&revs->diffopt, revs->diffopt.paths[0],
	311	revs->diffopt.paths[1]))
	312	return -1;
d516c2d1 JS	313	diffcore_std(&revs->diffopt);
d516c2d1 JS	314	diff_flush(&revs->diffopt);
34a5e1a2 JS	315	/*
	316	* The return code for --no-index imitates diff(1):
	317	* 0 = no changes, 1 = changes, else error
	318	*/
	319	return revs->diffopt.found_changes;
d516c2d1 JS	320	}
d516c2d1 JS	321
efdfd6c8 JH	322	if (read_cache() < 0) {
	323	perror("read_cache");
	324	return -1;
	325	}
d516c2d1 JS	326	return run_diff_files(revs, silent_on_removed);
	327	}
	328
6973dcae	329	int run_diff_files(struct rev_info *revs, int silent_on_removed)
f0c6b2a2	330	{
6973dcae JH	331	int entries, i;
6973dcae JH	332	int diff_unmerged_stage = revs->max_count;
f0c6b2a2	333
6973dcae JH	334	if (diff_unmerged_stage < 0)
6973dcae JH	335	diff_unmerged_stage = 2;
b4e1e4a7	336	entries = active_nr;
6973dcae	337	for (i = 0; i < entries; i++) {
be3cfa85	338	struct stat st;
6973dcae JH	339	unsigned int oldmode, newmode;
	340	struct cache_entry *ce = active_cache[i];
	341	int changed;
8676eb43	342
822cac01 JH	343	if (revs->diffopt.quiet && revs->diffopt.has_changes)
	344	break;
	345
6973dcae	346	if (!ce_path_match(ce, revs->prune_data))
8676eb43	347	continue;
be3cfa85	348
6973dcae	349	if (ce_stage(ce)) {
b4b15503	350	struct combine_diff_path *dpath;
6973dcae	351	int num_compare_stages = 0;
b4b15503	352	size_t path_len;
6973dcae	353
b4b15503 FF	354	path_len = ce_namelen(ce);
b4b15503 FF	355
4fc970c4	356	dpath = xmalloc(combine_diff_path_size(5, path_len));
b4b15503 FF	357	dpath->path = (char *) &(dpath->parent[5]);
	358
	359	dpath->next = NULL;
	360	dpath->len = path_len;
	361	memcpy(dpath->path, ce->name, path_len);
	362	dpath->path[path_len] = '\0';
a8e0d16d	363	hashclr(dpath->sha1);
b4b15503	364	memset(&(dpath->parent[0]), 0,
4fc970c4 JH	365	sizeof(struct combine_diff_parent)*5);
	366
	367	if (lstat(ce->name, &st) < 0) {
	368	if (errno != ENOENT && errno != ENOTDIR) {
	369	perror(ce->name);
	370	continue;
	371	}
	372	if (silent_on_removed)
	373	continue;
	374	}
	375	else
	376	dpath->mode = canon_mode(st.st_mode);
6973dcae JH	377
	378	while (i < entries) {
	379	struct cache_entry *nce = active_cache[i];
	380	int stage;
	381
	382	if (strcmp(ce->name, nce->name))
	383	break;
	384
	385	/* Stage #2 (ours) is the first parent,
	386	* stage #3 (theirs) is the second.
	387	*/
	388	stage = ce_stage(nce);
	389	if (2 <= stage) {
	390	int mode = ntohl(nce->ce_mode);
	391	num_compare_stages++;
e702496e	392	hashcpy(dpath->parent[stage-2].sha1, nce->sha1);
b4b15503	393	dpath->parent[stage-2].mode =
6973dcae	394	canon_mode(mode);
b4b15503	395	dpath->parent[stage-2].status =
6973dcae JH	396	DIFF_STATUS_MODIFIED;
	397	}
	398
	399	/* diff against the proper unmerged stage */
	400	if (stage == diff_unmerged_stage)
	401	ce = nce;
	402	i++;
	403	}
	404	/*
	405	* Compensate for loop update
f0c6b2a2	406	*/
6973dcae	407	i--;
6b5ee137	408
6973dcae	409	if (revs->combine_merges && num_compare_stages == 2) {
b4b15503	410	show_combined_diff(dpath, 2,
6973dcae JH	411	revs->dense_combined_merges,
6973dcae JH	412	revs);
b4b15503	413	free(dpath);
6973dcae	414	continue;
1b1480ff	415	}
b4b15503 FF	416	free(dpath);
b4b15503 FF	417	dpath = NULL;
0e3994fa	418
6973dcae JH	419	/*
	420	* Show the diff for the 'ce' if we found the one
	421	* from the desired stage.
	422	*/
e9c84099	423	diff_unmerge(&revs->diffopt, ce->name, 0, null_sha1);
6973dcae JH	424	if (ce_stage(ce) != diff_unmerged_stage)
6973dcae JH	425	continue;
eeaa4603	426	}
6b14d7fa	427
6973dcae JH	428	if (lstat(ce->name, &st) < 0) {
	429	if (errno != ENOENT && errno != ENOTDIR) {
	430	perror(ce->name);
15d061b4 JH	431	continue;
15d061b4 JH	432	}
6973dcae JH	433	if (silent_on_removed)
	434	continue;
	435	diff_addremove(&revs->diffopt, '-', ntohl(ce->ce_mode),
	436	ce->sha1, ce->name, NULL);
	437	continue;
f2ce9fde	438	}
6973dcae JH	439	changed = ce_match_stat(ce, &st, 0);
	440	if (!changed && !revs->diffopt.find_copies_harder)
	441	continue;
	442	oldmode = ntohl(ce->ce_mode);
be3cfa85	443
6973dcae JH	444	newmode = canon_mode(st.st_mode);
	445	if (!trust_executable_bit &&
	446	S_ISREG(newmode) && S_ISREG(oldmode) &&
	447	((newmode ^ oldmode) == 0111))
	448	newmode = oldmode;
78a8d641 JS	449	else if (!has_symlinks &&
	450	S_ISREG(newmode) && S_ISLNK(oldmode))
	451	newmode = oldmode;
6973dcae JH	452	diff_change(&revs->diffopt, oldmode, newmode,
	453	ce->sha1, (changed ? null_sha1 : ce->sha1),
	454	ce->name, NULL);
77eb2720	455
7ca45252	456	}
6973dcae JH	457	diffcore_std(&revs->diffopt);
	458	diff_flush(&revs->diffopt);
	459	return 0;
77eb2720	460	}
be3cfa85	461
e09ad6e1 JH	462	/*
	463	* diff-index
	464	*/
	465
	466	/* A file entry went away or appeared */
	467	static void diff_index_show_file(struct rev_info *revs,
	468	const char *prefix,
	469	struct cache_entry *ce,
	470	unsigned char *sha1, unsigned int mode)
	471	{
	472	diff_addremove(&revs->diffopt, prefix[0], ntohl(mode),
	473	sha1, ce->name, NULL);
	474	}
	475
	476	static int get_stat_data(struct cache_entry *ce,
	477	unsigned char **sha1p,
	478	unsigned int *modep,
	479	int cached, int match_missing)
	480	{
	481	unsigned char *sha1 = ce->sha1;
	482	unsigned int mode = ce->ce_mode;
	483
	484	if (!cached) {
	485	static unsigned char no_sha1[20];
	486	int changed;
	487	struct stat st;
	488	if (lstat(ce->name, &st) < 0) {
	489	if (errno == ENOENT && match_missing) {
	490	*sha1p = sha1;
	491	*modep = mode;
	492	return 0;
	493	}
	494	return -1;
	495	}
	496	changed = ce_match_stat(ce, &st, 0);
	497	if (changed) {
185c975f	498	mode = ce_mode_from_stat(ce, st.st_mode);
e09ad6e1 JH	499	sha1 = no_sha1;
	500	}
	501	}
	502
	503	*sha1p = sha1;
	504	*modep = mode;
	505	return 0;
	506	}
	507
	508	static void show_new_file(struct rev_info *revs,
	509	struct cache_entry *new,
	510	int cached, int match_missing)
	511	{
	512	unsigned char *sha1;
	513	unsigned int mode;
	514
	515	/* New file in the index: it might actually be different in
	516	* the working copy.
	517	*/
	518	if (get_stat_data(new, &sha1, &mode, cached, match_missing) < 0)
	519	return;
	520
	521	diff_index_show_file(revs, "+", new, sha1, mode);
	522	}
	523
	524	static int show_modified(struct rev_info *revs,
	525	struct cache_entry *old,
	526	struct cache_entry *new,
	527	int report_missing,
	528	int cached, int match_missing)
	529	{
	530	unsigned int mode, oldmode;
	531	unsigned char *sha1;
	532
	533	if (get_stat_data(new, &sha1, &mode, cached, match_missing) < 0) {
	534	if (report_missing)
	535	diff_index_show_file(revs, "-", old,
	536	old->sha1, old->ce_mode);
	537	return -1;
	538	}
	539
cb2b9f5e PM	540	if (revs->combine_merges && !cached &&
	541	(hashcmp(sha1, old->sha1) \|\| hashcmp(old->sha1, new->sha1))) {
	542	struct combine_diff_path *p;
	543	int pathlen = ce_namelen(new);
	544
	545	p = xmalloc(combine_diff_path_size(2, pathlen));
	546	p->path = (char *) &p->parent[2];
	547	p->next = NULL;
	548	p->len = pathlen;
	549	memcpy(p->path, new->name, pathlen);
	550	p->path[pathlen] = 0;
	551	p->mode = ntohl(mode);
	552	hashclr(p->sha1);
	553	memset(p->parent, 0, 2 * sizeof(struct combine_diff_parent));
	554	p->parent[0].status = DIFF_STATUS_MODIFIED;
	555	p->parent[0].mode = ntohl(new->ce_mode);
	556	hashcpy(p->parent[0].sha1, new->sha1);
	557	p->parent[1].status = DIFF_STATUS_MODIFIED;
	558	p->parent[1].mode = ntohl(old->ce_mode);
	559	hashcpy(p->parent[1].sha1, old->sha1);
	560	show_combined_diff(p, 2, revs->dense_combined_merges, revs);
	561	free(p);
	562	return 0;
	563	}
	564
e09ad6e1	565	oldmode = old->ce_mode;
a89fccd2	566	if (mode == oldmode && !hashcmp(sha1, old->sha1) &&
e09ad6e1 JH	567	!revs->diffopt.find_copies_harder)
	568	return 0;
	569
	570	mode = ntohl(mode);
	571	oldmode = ntohl(oldmode);
	572
	573	diff_change(&revs->diffopt, oldmode, mode,
	574	old->sha1, sha1, old->name, NULL);
	575	return 0;
	576	}
	577
	578	static int diff_cache(struct rev_info *revs,
	579	struct cache_entry **ac, int entries,
	580	const char **pathspec,
	581	int cached, int match_missing)
	582	{
	583	while (entries) {
	584	struct cache_entry ce = ac;
	585	int same = (entries > 1) && ce_same_name(ce, ac[1]);
	586
822cac01 JH	587	if (revs->diffopt.quiet && revs->diffopt.has_changes)
	588	break;
	589
e09ad6e1 JH	590	if (!ce_path_match(ce, pathspec))
	591	goto skip_entry;
	592
	593	switch (ce_stage(ce)) {
	594	case 0:
	595	/* No stage 1 entry? That means it's a new file */
	596	if (!same) {
	597	show_new_file(revs, ce, cached, match_missing);
	598	break;
	599	}
	600	/* Show difference between old and new */
1cfe7733	601	show_modified(revs, ac[1], ce, 1,
e09ad6e1 JH	602	cached, match_missing);
	603	break;
	604	case 1:
	605	/* No stage 3 (merge) entry?
	606	* That means it's been deleted.
	607	*/
	608	if (!same) {
	609	diff_index_show_file(revs, "-", ce,
	610	ce->sha1, ce->ce_mode);
	611	break;
	612	}
	613	/* We come here with ce pointing at stage 1
	614	* (original tree) and ac[1] pointing at stage
	615	* 3 (unmerged). show-modified with
	616	* report-missing set to false does not say the
	617	* file is deleted but reports true if work
	618	* tree does not have it, in which case we
	619	* fall through to report the unmerged state.
	620	* Otherwise, we show the differences between
	621	* the original tree and the work tree.
	622	*/
	623	if (!cached &&
	624	!show_modified(revs, ce, ac[1], 0,
	625	cached, match_missing))
	626	break;
e9c84099 JH	627	diff_unmerge(&revs->diffopt, ce->name,
	628	ntohl(ce->ce_mode), ce->sha1);
	629	break;
e09ad6e1	630	case 3:
e9c84099 JH	631	diff_unmerge(&revs->diffopt, ce->name,
e9c84099 JH	632	0, null_sha1);
e09ad6e1 JH	633	break;
	634
	635	default:
	636	die("impossible cache entry stage");
	637	}
	638
	639	skip_entry:
	640	/*
	641	* Ignore all the different stages for this file,
	642	* we've handled the relevant cases now.
	643	*/
	644	do {
	645	ac++;
	646	entries--;
	647	} while (entries && ce_same_name(ce, ac[0]));
	648	}
	649	return 0;
	650	}
	651
	652	/*
	653	* This turns all merge entries into "stage 3". That guarantees that
	654	* when we read in the new tree (into "stage 1"), we won't lose sight
	655	* of the fact that we had unmerged entries.
	656	*/
	657	static void mark_merge_entries(void)
	658	{
	659	int i;
	660	for (i = 0; i < active_nr; i++) {
	661	struct cache_entry *ce = active_cache[i];
	662	if (!ce_stage(ce))
	663	continue;
	664	ce->ce_flags \|= htons(CE_STAGEMASK);
	665	}
	666	}
	667
5c21ac0e	668	int run_diff_index(struct rev_info *revs, int cached)
e09ad6e1 JH	669	{
	670	int ret;
	671	struct object *ent;
	672	struct tree *tree;
	673	const char *tree_name;
5c21ac0e JH	674	int match_missing = 0;
	675
	676	/*
	677	* Backward compatibility wart - "diff-index -m" does
	678	* not mean "do not ignore merges", but totally different.
	679	*/
	680	if (!revs->ignore_merges)
	681	match_missing = 1;
e09ad6e1	682
e09ad6e1 JH	683	mark_merge_entries();
e09ad6e1 JH	684
1f1e895f LT	685	ent = revs->pending.objects[0].item;
1f1e895f LT	686	tree_name = revs->pending.objects[0].name;
e09ad6e1 JH	687	tree = parse_tree_indirect(ent->sha1);
	688	if (!tree)
	689	return error("bad tree object %s", tree_name);
	690	if (read_tree(tree, 1, revs->prune_data))
	691	return error("unable to read tree object %s", tree_name);
	692	ret = diff_cache(revs, active_cache, active_nr, revs->prune_data,
	693	cached, match_missing);
	694	diffcore_std(&revs->diffopt);
	695	diff_flush(&revs->diffopt);
	696	return ret;
	697	}
1cfe7733 JH	698
	699	int do_diff_cache(const unsigned char tree_sha1, struct diff_options opt)
	700	{
	701	struct tree *tree;
	702	struct rev_info revs;
	703	int i;
	704	struct cache_entry **dst;
	705	struct cache_entry *last = NULL;
	706
	707	/*
	708	* This is used by git-blame to run diff-cache internally;
	709	* it potentially needs to repeatedly run this, so we will
	710	* start by removing the higher order entries the last round
	711	* left behind.
	712	*/
	713	dst = active_cache;
	714	for (i = 0; i < active_nr; i++) {
	715	struct cache_entry *ce = active_cache[i];
	716	if (ce_stage(ce)) {
	717	if (last && !strcmp(ce->name, last->name))
	718	continue;
	719	cache_tree_invalidate_path(active_cache_tree,
	720	ce->name);
	721	last = ce;
	722	ce->ce_mode = 0;
	723	ce->ce_flags &= ~htons(CE_STAGEMASK);
	724	}
	725	*dst++ = ce;
	726	}
	727	active_nr = dst - active_cache;
	728
	729	init_revisions(&revs, NULL);
	730	revs.prune_data = opt->paths;
	731	tree = parse_tree_indirect(tree_sha1);
	732	if (!tree)
	733	die("bad tree object %s", sha1_to_hex(tree_sha1));
	734	if (read_tree(tree, 1, opt->paths))
	735	return error("unable to read tree %s", sha1_to_hex(tree_sha1));
	736	return diff_cache(&revs, active_cache, active_nr, revs.prune_data,
	737	1, 0);
	738	}