X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=apply.c;h=1f48ef906fbf6c0f0a2efb6bf06599aa3081d30a;hb=9b63f50148bd155c00b6893dbbf48583f7b0848d;hp=3606419f9e96e0f4bd33de08c4d64a3f30d2fb4c;hpb=5041aa70405d2359114b285e7c97b877aa0c079a;p=git.git

diff --git a/apply.c b/apply.c
index 3606419f..1f48ef90 100644
--- a/apply.c
+++ b/apply.c
@@ -17,11 +17,21 @@
 #include "cache.h"
 
 // We default to the merge behaviour, since that's what most people would
-// expect
+// expect.
+//
+//  --check turns on checking that the working tree matches the
+//    files that are being modified, but doesn't apply the patch
+//  --stat does just a diffstat, and doesn't actually apply
+//  --show-files shows the directory changes
+//
 static int merge_patch = 1;
+static int check_index = 0;
+static int write_index = 0;
 static int diffstat = 0;
-static int check = 1;
-static const char apply_usage[] = "git-apply <patch>";
+static int check = 0;
+static int apply = 1;
+static int show_files = 0;
+static const char apply_usage[] = "git-apply [--stat] [--check] [--show-files] <patch>";
 
 /*
  * For "diff-stat" like behaviour, we keep track of the biggest change
@@ -51,6 +61,8 @@ struct patch {
 	int is_rename, is_copy, is_new, is_delete;
 	int lines_added, lines_deleted;
 	struct fragment *fragments;
+	char *result;
+	unsigned long resultsize;
 	struct patch *next;
 };
 
@@ -92,7 +104,7 @@ static void *read_patch_file(int fd, unsigned long *sizep)
 	return buffer;
 }
 
-static unsigned long linelen(char *buffer, unsigned long size)
+static unsigned long linelen(const char *buffer, unsigned long size)
 {
 	unsigned long len = 0;
 	while (size--) {
@@ -108,9 +120,8 @@ static int is_dev_null(const char *str)
 	return !memcmp("/dev/null", str, 9) && isspace(str[9]);
 }
 
-#define TERM_EXIST	1
-#define TERM_SPACE	2
-#define TERM_TAB	4
+#define TERM_SPACE	1
+#define TERM_TAB	2
 
 static int name_terminate(const char *name, int namelen, int c, int terminate)
 {
@@ -119,13 +130,6 @@ static int name_terminate(const char *name, int namelen, int c, int terminate)
 	if (c == '\t' && !(terminate & TERM_TAB))
 		return 0;
 
-	/*
-	 * Do we want an existing name? Return false and
-	 * continue if it's not there.
-	 */
-	if (terminate & TERM_EXIST)
-		return cache_name_pos(name, namelen) >= 0;
-
 	return 1;
 }
 
@@ -197,11 +201,11 @@ static void parse_traditional_patch(const char *first, const char *second, struc
 	} else if (is_dev_null(second)) {
 		patch->is_new = 0;
 		patch->is_delete = 1;
-		name = find_name(first, NULL, p_value, TERM_EXIST | TERM_SPACE | TERM_TAB);
+		name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
 		patch->old_name = name;
 	} else {
-		name = find_name(first, NULL, p_value, TERM_EXIST | TERM_SPACE | TERM_TAB);
-		name = find_name(second, name, p_value, TERM_EXIST | TERM_SPACE | TERM_TAB);
+		name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
+		name = find_name(second, name, p_value, TERM_SPACE | TERM_TAB);
 		patch->old_name = patch->new_name = name;
 	}
 	if (!name)
@@ -328,6 +332,11 @@ static int gitdiff_similarity(const char *line, struct patch *patch)
 	return 0;
 }
 
+static int gitdiff_dissimilarity(const char *line, struct patch *patch)
+{
+	return 0;
+}
+
 /*
  * This is normal for a diff that doesn't change anything: we'll fall through
  * into the next diff. Tell the parser to break out.
@@ -381,7 +390,7 @@ static char *git_header_name(char *line)
 				if (c == '/')
 					break;
 			}
-			if (!memcmp(name, second, len)) {
+			if (second[len] == '\n' && !memcmp(name, second, len)) {
 				char *ret = xmalloc(len + 1);
 				memcpy(ret, name, len);
 				ret[len] = 0;
@@ -426,9 +435,12 @@ static int parse_git_header(char *line, int len, unsigned int size, struct patch
 			{ "new file mode ", gitdiff_newfile },
 			{ "copy from ", gitdiff_copysrc },
 			{ "copy to ", gitdiff_copydst },
+			{ "rename old ", gitdiff_renamesrc },
+			{ "rename new ", gitdiff_renamedst },
 			{ "rename from ", gitdiff_renamesrc },
 			{ "rename to ", gitdiff_renamedst },
 			{ "similarity index ", gitdiff_similarity },
+			{ "dissimilarity index ", gitdiff_dissimilarity },
 			{ "", gitdiff_unrecognized },
 		};
 		int i;
@@ -559,7 +571,7 @@ static int find_header(char *line, unsigned long size, int *hdrsize, struct patc
 			if (git_hdr_len < 0)
 				continue;
 			if (!patch->old_name && !patch->new_name)
-				die("git diff header lacks filename information");
+				die("git diff header lacks filename information (line %d)", linenr);
 			*hdrsize = git_hdr_len;
 			return offset;
 		}
@@ -597,7 +609,7 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s
 {
 	int added, deleted;
 	int len = linelen(line, size), offset;
-	unsigned long pos[4], oldlines, newlines;
+	unsigned long oldlines, newlines;
 
 	offset = parse_fragment_header(line, len, fragment);
 	if (offset < 0)
@@ -605,10 +617,21 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s
 	oldlines = fragment->oldlines;
 	newlines = fragment->newlines;
 
-	if (patch->is_new < 0 && (pos[0] || oldlines))
-		patch->is_new = 0;
-	if (patch->is_delete < 0 && (pos[1] || newlines))
-		patch->is_delete = 0;
+	if (patch->is_new < 0) {
+		patch->is_new =  !oldlines;
+		if (!oldlines)
+			patch->old_name = NULL;
+	}
+	if (patch->is_delete < 0) {
+		patch->is_delete = !newlines;
+		if (!newlines)
+			patch->new_name = NULL;
+	}
+
+	if (patch->is_new != !oldlines)
+		return error("new file depends on old contents");
+	if (patch->is_delete != !newlines)
+		return error("deleted file still has contents");
 
 	/* Parse the thing.. */
 	line += len;
@@ -638,6 +661,8 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s
 			break;
 		/* We allow "\ No newline at end of file" */
 		case '\\':
+			if (len < 12 || memcmp(line, "\\ No newline", 12))
+				return -1;
 			break;
 		}
 	}
@@ -693,7 +718,7 @@ const char minuses[]= "---------------------------------------------------------
 static void show_stats(struct patch *patch)
 {
 	char *name = patch->old_name;
-	int len, max, add, del;
+	int len, max, add, del, total;
 
 	if (!name)
 		name = patch->new_name;
@@ -715,52 +740,348 @@ static void show_stats(struct patch *patch)
 	max = max_change;
 	if (max + len > 70)
 		max = 70 - len;
-	
-	add = (patch->lines_added * max + max_change/2) / max_change;
-	del = (patch->lines_deleted * max + max_change/2) / max_change;
+
+	add = patch->lines_added;
+	del = patch->lines_deleted;
+	total = add + del;
+
+	total = (total * max + max_change / 2) / max_change;
+	add = (add * max + max_change / 2) / max_change;
+	del = total - add;
 	printf(" %-*s |%5d %.*s%.*s\n",
 		len, name, patch->lines_added + patch->lines_deleted,
 		add, pluses, del, minuses);
 }
 
-static void check_patch(struct patch *patch)
+static int read_old_data(struct stat *st, const char *path, void *buf, unsigned long size)
+{
+	int fd;
+	unsigned long got;
+
+	switch (st->st_mode & S_IFMT) {
+	case S_IFLNK:
+		return readlink(path, buf, size);
+	case S_IFREG:
+		fd = open(path, O_RDONLY);
+		if (fd < 0)
+			return error("unable to open %s", path);
+		got = 0;
+		for (;;) {
+			int ret = read(fd, buf + got, size - got);
+			if (ret < 0) {
+				if (errno == EAGAIN)
+					continue;
+				break;
+			}
+			if (!ret)
+				break;
+			got += ret;
+		}
+		close(fd);
+		return got;
+
+	default:
+		return -1;
+	}
+}
+
+static int find_offset(const char *buf, unsigned long size, const char *fragment, unsigned long fragsize, int line)
+{
+	int i;
+	unsigned long start, backwards, forwards;
+
+	if (fragsize > size)
+		return -1;
+
+	start = 0;
+	if (line > 1) {
+		unsigned long offset = 0;
+		i = line-1;
+		while (offset + fragsize <= size) {
+			if (buf[offset++] == '\n') {
+				start = offset;
+				if (!--i)
+					break;
+			}
+		}
+	}
+
+	/* Exact line number? */
+	if (!memcmp(buf + start, fragment, fragsize))
+		return start;
+
+	/*
+	 * There's probably some smart way to do this, but I'll leave
+	 * that to the smart and beautiful people. I'm simple and stupid.
+	 */
+	backwards = start;
+	forwards = start;
+	for (i = 0; ; i++) {
+		unsigned long try;
+		int n;
+
+		/* "backward" */
+		if (i & 1) {
+			if (!backwards) {
+				if (forwards + fragsize > size)
+					break;
+				continue;
+			}
+			do {
+				--backwards;
+			} while (backwards && buf[backwards-1] != '\n');
+			try = backwards;
+		} else {
+			while (forwards + fragsize <= size) {
+				if (buf[forwards++] == '\n')
+					break;
+			}
+			try = forwards;
+		}
+
+		if (try + fragsize > size)
+			continue;
+		if (memcmp(buf + try, fragment, fragsize))
+			continue;
+		n = (i >> 1)+1;
+		if (i & 1)
+			n = -n;
+		fprintf(stderr, "Fragment applied at offset %d\n", n);
+		return try;
+	}
+
+	/*
+	 * We should start searching forward and backward.
+	 */
+	return -1;
+}
+
+struct buffer_desc {
+	char *buffer;
+	unsigned long size;
+	unsigned long alloc;
+};
+
+static int apply_one_fragment(struct buffer_desc *desc, struct fragment *frag)
+{
+	char *buf = desc->buffer;
+	const char *patch = frag->patch;
+	int offset, size = frag->size;
+	char *old = xmalloc(size);
+	char *new = xmalloc(size);
+	int oldsize = 0, newsize = 0;
+
+	while (size > 0) {
+		int len = linelen(patch, size);
+		int plen;
+
+		if (!len)
+			break;
+
+		/*
+		 * "plen" is how much of the line we should use for
+		 * the actual patch data. Normally we just remove the
+		 * first character on the line, but if the line is
+		 * followed by "\ No newline", then we also remove the
+		 * last one (which is the newline, of course).
+		 */
+		plen = len-1;
+		if (len > size && patch[len] == '\\')
+			plen--;
+		switch (*patch) {
+		case ' ':
+		case '-':
+			memcpy(old + oldsize, patch + 1, plen);
+			oldsize += plen;
+			if (*patch == '-')
+				break;
+		/* Fall-through for ' ' */
+		case '+':
+			memcpy(new + newsize, patch + 1, plen);
+			newsize += plen;
+			break;
+		case '@': case '\\':
+			/* Ignore it, we already handled it */
+			break;
+		default:
+			return -1;
+		}
+		patch += len;
+		size -= len;
+	}
+
+	offset = find_offset(buf, desc->size, old, oldsize, frag->newpos);
+	if (offset >= 0) {
+		int diff = newsize - oldsize;
+		unsigned long size = desc->size + diff;
+		unsigned long alloc = desc->alloc;
+
+		if (size > alloc) {
+			alloc = size + 8192;
+			desc->alloc = alloc;
+			buf = xrealloc(buf, alloc);
+			desc->buffer = buf;
+		}
+		desc->size = size;
+		memmove(buf + offset + newsize, buf + offset + oldsize, size - offset - newsize);
+		memcpy(buf + offset, new, newsize);
+		offset = 0;
+	}
+
+	free(old);
+	free(new);
+	return offset;
+}
+
+static int apply_fragments(struct buffer_desc *desc, struct patch *patch)
+{
+	struct fragment *frag = patch->fragments;
+
+	while (frag) {
+		if (apply_one_fragment(desc, frag) < 0)
+			return error("patch failed: %s:%d", patch->old_name, frag->oldpos);
+		frag = frag->next;
+	}
+	return 0;
+}
+
+static int apply_data(struct patch *patch, struct stat *st)
+{
+	char *buf;
+	unsigned long size, alloc;
+	struct buffer_desc desc;
+
+	size = 0;
+	alloc = 0;
+	buf = NULL;
+	if (patch->old_name) {
+		size = st->st_size;
+		alloc = size + 8192;
+		buf = xmalloc(alloc);
+		if (read_old_data(st, patch->old_name, buf, alloc) != size)
+			return error("read of %s failed", patch->old_name);
+	}
+
+	desc.size = size;
+	desc.alloc = alloc;
+	desc.buffer = buf;
+	if (apply_fragments(&desc, patch) < 0)
+		return -1;
+	patch->result = desc.buffer;
+	patch->resultsize = desc.size;
+
+	if (patch->is_delete && patch->resultsize)
+		return error("removal patch leaves file contents");
+
+	return 0;
+}
+
+static int check_patch(struct patch *patch)
 {
+	struct stat st;
 	const char *old_name = patch->old_name;
 	const char *new_name = patch->new_name;
 
 	if (old_name) {
-		if (cache_name_pos(old_name, strlen(old_name)) < 0)
-			die("file %s does not exist", old_name);
+		int changed;
+
+		if (lstat(old_name, &st) < 0)
+			return error("%s: %s\n", strerror(errno));
+		if (check_index) {
+			int pos = cache_name_pos(old_name, strlen(old_name));
+			if (pos < 0)
+				return error("%s: does not exist in index", old_name);
+			changed = ce_match_stat(active_cache[pos], &st);
+			if (changed)
+				return error("%s: does not match index", old_name);
+		}
 		if (patch->is_new < 0)
 			patch->is_new = 0;
+		if (!patch->old_mode)
+			patch->old_mode = st.st_mode;
+		if ((st.st_mode ^ patch->old_mode) & S_IFMT)
+			return error("%s: wrong type", old_name);
+		if (st.st_mode != patch->old_mode)
+			fprintf(stderr, "warning: %s has type %o, expected %o\n",
+				old_name, st.st_mode, patch->old_mode);
 	}
+
 	if (new_name && (patch->is_new | patch->is_rename | patch->is_copy)) {
-		if (cache_name_pos(new_name, strlen(new_name)) >= 0)
-			die("file %s already exists", new_name);
+		if (check_index && cache_name_pos(new_name, strlen(new_name)) >= 0)
+			return error("%s: already exists in index", new_name);
+		if (!lstat(new_name, &st))
+			return error("%s: already exists in working directory", new_name);
+		if (errno != ENOENT)
+			return error("%s: %s", new_name, strerror(errno));
+		if (!patch->new_mode)
+			patch->new_mode = S_IFREG | 0644;
 	}
+
+	if (new_name && old_name) {
+		int same = !strcmp(old_name, new_name);
+		if (!patch->new_mode)
+			patch->new_mode = patch->old_mode;
+		if ((patch->old_mode ^ patch->new_mode) & S_IFMT)
+			return error("new mode (%o) of %s does not match old mode (%o)%s%s",
+				patch->new_mode, new_name, patch->old_mode,
+				same ? "" : " of ", same ? "" : old_name);
+	}	
+
+	if (apply_data(patch, &st) < 0)
+		return error("%s: patch does not apply", old_name);
+	return 0;
 }
 
-static void apply_patch_list(struct patch *patch)
+static int check_patch_list(struct patch *patch)
 {
-	int files, adds, dels;
+	int error = 0;
 
-	files = adds = dels = 0;
-	if (!patch)
-		die("no patch found");
-	do {
-		if (check)
-			check_patch(patch);
-
-		if (diffstat) {
-			files++;
-			adds += patch->lines_added;
-			dels += patch->lines_deleted;
-			show_stats(patch);
+	for (;patch ; patch = patch->next)
+		error |= check_patch(patch);
+	return error;
+}
+
+static void show_file(int c, unsigned int mode, const char *name)
+{
+	printf("%c %o %s\n", c, mode, name);
+}
+
+static void show_file_list(struct patch *patch)
+{
+	for (;patch ; patch = patch->next) {
+		if (patch->is_rename) {
+			show_file('-', patch->old_mode, patch->old_name);
+			show_file('+', patch->new_mode, patch->new_name);
+			continue;
 		}
-	} while ((patch = patch->next) != NULL);
+		if (patch->is_copy || patch->is_new) {
+			show_file('+', patch->new_mode, patch->new_name);
+			continue;
+		}
+		if (patch->is_delete) {
+			show_file('-', patch->old_mode, patch->old_name);
+			continue;
+		}
+		if (patch->old_mode && patch->new_mode && patch->old_mode != patch->new_mode) {
+			printf("M %o:%o %s\n", patch->old_mode, patch->new_mode, patch->old_name);
+			continue;
+		}
+		printf("M %o %s\n", patch->old_mode, patch->old_name);
+	}
+}
 
-	if (diffstat)
-		printf(" %d files changed, %d insertions(+), %d deletions(-)\n", files, adds, dels);
+static void stat_patch_list(struct patch *patch)
+{
+	int files, adds, dels;
+
+	for (files = adds = dels = 0 ; patch ; patch = patch->next) {
+		files++;
+		adds += patch->lines_added;
+		dels += patch->lines_deleted;
+		show_stats(patch);
+	}
+
+	printf(" %d files changed, %d insertions(+), %d deletions(-)\n", files, adds, dels);
 }
 
 static void patch_stats(struct patch *patch)
@@ -781,8 +1102,106 @@ static void patch_stats(struct patch *patch)
 	}
 }
 
+static void remove_file(struct patch *patch)
+{
+	if (write_index) {
+		if (remove_file_from_cache(patch->old_name) < 0)
+			die("unable to remove %s from index", patch->old_name);
+	}
+	unlink(patch->old_name);
+}
+
+static void add_index_file(const char *path, unsigned mode, void *buf, unsigned long size)
+{
+	struct stat st;
+	struct cache_entry *ce;
+	int namelen = strlen(path);
+	unsigned ce_size = cache_entry_size(namelen);
+
+	if (!write_index)
+		return;
+
+	ce = xmalloc(ce_size);
+	memset(ce, 0, ce_size);
+	memcpy(ce->name, path, namelen);
+	ce->ce_mode = create_ce_mode(mode);
+	ce->ce_flags = htons(namelen);
+	if (lstat(path, &st) < 0)
+		die("unable to stat newly created file %s", path);
+	fill_stat_cache_info(ce, &st);
+	if (write_sha1_file(buf, size, "blob", ce->sha1) < 0)
+		die("unable to create backing store for newly created file %s", path);
+	if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)
+		die("unable to add cache entry for %s", path);
+}
+
+static void create_file(struct patch *patch)
+{
+	const char *path = patch->new_name;
+	unsigned mode = patch->new_mode;
+	unsigned long size = patch->resultsize;
+	char *buf = patch->result;
+
+	if (!mode)
+		mode = S_IFREG | 0644;
+	if (S_ISREG(mode)) {
+		int fd;
+		mode = (mode & 0100) ? 0777 : 0666;
+		fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
+		if (fd < 0)
+			die("unable to create file %s (%s)", path, strerror(errno));
+		if (write(fd, buf, size) != size)
+			die("unable to write file %s", path);
+		close(fd);
+		add_index_file(path, mode, buf, size);
+		return;
+	}
+	if (S_ISLNK(mode)) {
+		if (size && buf[size-1] == '\n')
+			size--;
+		buf[size] = 0;
+		if (symlink(buf, path) < 0)
+			die("unable to write symlink %s", path);
+		add_index_file(path, mode, buf, size);
+		return;
+	}
+	die("unable to write file mode %o", mode);
+}
+
+static void write_out_one_result(struct patch *patch)
+{
+	if (patch->is_delete > 0) {
+		remove_file(patch);
+		return;
+	}
+	if (patch->is_new > 0 || patch->is_copy) {
+		create_file(patch);
+		return;
+	}
+	/*
+	 * Rename or modification boils down to the same
+	 * thing: remove the old, write the new
+	 */
+	remove_file(patch);
+	create_file(patch);
+}
+
+static void write_out_results(struct patch *list)
+{
+	if (!list)
+		die("No changes");
+
+	while (list) {
+		write_out_one_result(list);
+		list = list->next;
+	}
+}
+
+static struct cache_file cache_file;
+
 static int apply_patch(int fd)
 {
+	int newfd;
 	unsigned long offset, size;
 	char *buffer = read_patch_file(fd, &size);
 	struct patch *list = NULL, **listp = &list;
@@ -806,7 +1225,32 @@ static int apply_patch(int fd)
 		size -= nr;
 	}
 
-	apply_patch_list(list);
+	newfd = -1;
+	write_index = check_index && apply;
+	if (write_index)
+		newfd = hold_index_file_for_update(&cache_file, get_index_file());
+	if (check_index) {
+		if (read_cache() < 0)
+			die("unable to read index file");
+	}
+
+	if ((check || apply) && check_patch_list(list) < 0)
+		exit(1);
+
+	if (apply)
+		write_out_results(list);
+
+	if (write_index) {
+		if (write_cache(newfd, active_cache, active_nr) ||
+		    commit_index_file(&cache_file))
+			die("Unable to write new cachefile");
+	}
+
+	if (show_files)
+		show_file_list(list);
+
+	if (diffstat)
+		stat_patch_list(list);
 
 	free(buffer);
 	return 0;
@@ -817,9 +1261,6 @@ int main(int argc, char **argv)
 	int i;
 	int read_stdin = 1;
 
-	if (read_cache() < 0)
-		die("unable to read index file");
-
 	for (i = 1; i < argc; i++) {
 		const char *arg = argv[i];
 		int fd;
@@ -834,10 +1275,23 @@ int main(int argc, char **argv)
 			continue;
 		}
 		if (!strcmp(arg, "--stat")) {
-			check = 0;
+			apply = 0;
 			diffstat = 1;
 			continue;
 		}
+		if (!strcmp(arg, "--check")) {
+			apply = 0;
+			check = 1;
+			continue;
+		}
+		if (!strcmp(arg, "--index")) {
+			check_index = 1;
+			continue;
+		}
+		if (!strcmp(arg, "--show-files")) {
+			show_files = 1;
+			continue;
+		}
 		fd = open(arg, O_RDONLY);
 		if (fd < 0)
 			usage(apply_usage);