X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=apply.c;h=c81b0a240a38b57a9bbd2586889304bef8f5cbbf;hb=180926636e47ecfe28d03cec493af75899994f0f;hp=00216ec69f50b88c526d186a027c2f8bbb55c353;hpb=3cca928d4aae691572ef9a73dcc29a04f66900a1;p=git.git

diff --git a/apply.c b/apply.c
index 00216ec6..c81b0a24 100644
--- a/apply.c
+++ b/apply.c
@@ -26,11 +26,13 @@
 //
 static int merge_patch = 1;
 static int check_index = 0;
+static int write_index = 0;
 static int diffstat = 0;
+static int summary = 0;
 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>";
+static const char apply_usage[] = "git-apply [--stat] [--summary] [--check] [--show-files] <patch>";
 
 /*
  * For "diff-stat" like behaviour, we keep track of the biggest change
@@ -59,8 +61,9 @@ struct patch {
 	unsigned int old_mode, new_mode;
 	int is_rename, is_copy, is_new, is_delete;
 	int lines_added, lines_deleted;
+	int score;
 	struct fragment *fragments;
-	const char *result;
+	char *result;
 	unsigned long resultsize;
 	struct patch *next;
 };
@@ -328,11 +331,15 @@ static int gitdiff_renamedst(const char *line, struct patch *patch)
 
 static int gitdiff_similarity(const char *line, struct patch *patch)
 {
+	if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
+		patch->score = 0;
 	return 0;
 }
 
 static int gitdiff_dissimilarity(const char *line, struct patch *patch)
 {
+	if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
+		patch->score = 0;
 	return 0;
 }
 
@@ -434,6 +441,8 @@ 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 },
@@ -565,10 +574,13 @@ static int find_header(char *line, unsigned long size, int *hdrsize, struct patc
 		 */
 		if (!memcmp("diff --git ", line, 11)) {
 			int git_hdr_len = parse_git_header(line, len, size, patch);
-			if (git_hdr_len < 0)
+			if (git_hdr_len <= len)
 				continue;
-			if (!patch->old_name && !patch->new_name)
-				die("git diff header lacks filename information");
+			if (!patch->old_name && !patch->new_name) {
+				if (!patch->def_name)
+					die("git diff header lacks filename information (line %d)", linenr);
+				patch->old_name = patch->new_name = patch->def_name;
+			}
 			*hdrsize = git_hdr_len;
 			return offset;
 		}
@@ -606,7 +618,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)
@@ -614,10 +626,24 @@ 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) {
+		if (newlines)
+			return error("deleted file still has contents");
+		fprintf(stderr, "** warning: file %s becomes empty but is not deleted\n", patch->new_name);
+	}
 
 	/* Parse the thing.. */
 	line += len;
@@ -703,11 +729,11 @@ const char minuses[]= "---------------------------------------------------------
 
 static void show_stats(struct patch *patch)
 {
-	char *name = patch->old_name;
+	char *name = patch->new_name;
 	int len, max, add, del, total;
 
 	if (!name)
-		name = patch->new_name;
+		name = patch->old_name;
 
 	/*
 	 * "scale" the filename
@@ -731,9 +757,11 @@ static void show_stats(struct patch *patch)
 	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;
+	if (max_change > 0) {
+		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);
@@ -773,19 +801,20 @@ static int read_old_data(struct stat *st, const char *path, void *buf, unsigned
 
 static int find_offset(const char *buf, unsigned long size, const char *fragment, unsigned long fragsize, int line)
 {
-	unsigned long start;
+	int i;
+	unsigned long start, backwards, forwards;
 
 	if (fragsize > size)
 		return -1;
 
 	start = 0;
 	if (line > 1) {
-		line--;
 		unsigned long offset = 0;
-		while (start + offset <= size) {
+		i = line-1;
+		while (offset + fragsize <= size) {
 			if (buf[offset++] == '\n') {
 				start = offset;
-				if (!--line)
+				if (!--i)
 					break;
 			}
 		}
@@ -796,13 +825,59 @@ static int find_offset(const char *buf, unsigned long size, const char *fragment
 		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;
+		return try;
+	}
+
+	/*
 	 * We should start searching forward and backward.
 	 */
 	return -1;
 }
 
-static int apply_one_fragment(char *buf, unsigned long *sizep, unsigned long *bufsizep, struct fragment *frag)
+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);
@@ -848,9 +923,21 @@ static int apply_one_fragment(char *buf, unsigned long *sizep, unsigned long *bu
 		size -= len;
 	}
 
-	offset = find_offset(buf, *sizep, old, oldsize, frag->newpos);
+	offset = find_offset(buf, desc->size, old, oldsize, frag->newpos);
 	if (offset >= 0) {
-		printf("found at offset %d\n", offset);
+		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;
 	}
 
@@ -859,31 +946,46 @@ static int apply_one_fragment(char *buf, unsigned long *sizep, unsigned long *bu
 	return offset;
 }
 
-static int apply_fragments(char *buf, unsigned long *sizep, unsigned long *bufsizep, struct patch *patch)
+static int apply_fragments(struct buffer_desc *desc, struct patch *patch)
 {
 	struct fragment *frag = patch->fragments;
 
 	while (frag) {
-		if (apply_one_fragment(buf, sizep, bufsizep, frag) < 0)
+		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)
 {
-	unsigned long size, bufsize;
-	void *buf;
+	char *buf;
+	unsigned long size, alloc;
+	struct buffer_desc desc;
 
-	if (!patch->old_name || !patch->fragments)
-		return 0;
-	size = st->st_size;
-	bufsize = size + 16;
-	buf = xmalloc(bufsize);
-	if (read_old_data(st, patch->old_name, buf, bufsize) != size)
-		return error("read of %s failed", patch->old_name);
-	if (apply_fragments(buf, &size, &bufsize, patch) < 0)
+	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;
 }
 
@@ -897,7 +999,7 @@ static int check_patch(struct patch *patch)
 		int changed;
 
 		if (lstat(old_name, &st) < 0)
-			return error("%s: %s\n", strerror(errno));
+			return error("%s: %s", old_name, strerror(errno));
 		if (check_index) {
 			int pos = cache_name_pos(old_name, strlen(old_name));
 			if (pos < 0)
@@ -908,6 +1010,7 @@ static int check_patch(struct patch *patch)
 		}
 		if (patch->is_new < 0)
 			patch->is_new = 0;
+		st.st_mode = ntohl(create_ce_mode(st.st_mode));
 		if (!patch->old_mode)
 			patch->old_mode = st.st_mode;
 		if ((st.st_mode ^ patch->old_mode) & S_IFMT)
@@ -924,6 +1027,8 @@ static int check_patch(struct patch *patch)
 			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) {
@@ -993,6 +1098,84 @@ static void stat_patch_list(struct patch *patch)
 	printf(" %d files changed, %d insertions(+), %d deletions(-)\n", files, adds, dels);
 }
 
+static void show_file_mode_name(const char *newdelete, unsigned int mode, const char *name)
+{
+	if (mode)
+		printf(" %s mode %06o %s\n", newdelete, mode, name);
+	else
+		printf(" %s %s\n", newdelete, name);
+}
+
+static void show_mode_change(struct patch *p, int show_name)
+{
+	if (p->old_mode && p->new_mode && p->old_mode != p->new_mode) {
+		if (show_name)
+			printf(" mode change %06o => %06o %s\n",
+			       p->old_mode, p->new_mode, p->new_name);
+		else
+			printf(" mode change %06o => %06o\n",
+			       p->old_mode, p->new_mode);
+	}
+}
+
+static void show_rename_copy(struct patch *p)
+{
+	const char *renamecopy = p->is_rename ? "rename" : "copy";
+	const char *old, *new;
+
+	/* Find common prefix */
+	old = p->old_name;
+	new = p->new_name;
+	while (1) {
+		const char *slash_old, *slash_new;
+		slash_old = strchr(old, '/');
+		slash_new = strchr(new, '/');
+		if (!slash_old ||
+		    !slash_new ||
+		    slash_old - old != slash_new - new ||
+		    memcmp(old, new, slash_new - new))
+			break;
+		old = slash_old + 1;
+		new = slash_new + 1;
+	}
+	/* p->old_name thru old is the common prefix, and old and new
+	 * through the end of names are renames
+	 */
+	if (old != p->old_name)
+		printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,
+		       old - p->old_name, p->old_name,
+		       old, new, p->score);
+	else
+		printf(" %s %s => %s (%d%%)\n", renamecopy,
+		       p->old_name, p->new_name, p->score);
+	show_mode_change(p, 0);
+}
+
+static void summary_patch_list(struct patch *patch)
+{
+	struct patch *p;
+
+	for (p = patch; p; p = p->next) {
+		if (p->is_new)
+			show_file_mode_name("create", p->new_mode, p->new_name);
+		else if (p->is_delete)
+			show_file_mode_name("delete", p->old_mode, p->old_name);
+		else {
+			if (p->is_rename || p->is_copy)
+				show_rename_copy(p);
+			else {
+				if (p->score) {
+					printf(" rewrite %s (%d%%)\n",
+					       p->new_name, p->score);
+					show_mode_change(p, 0);
+				}
+				else
+					show_mode_change(p, 1);
+			}
+		}
+	}
+}
+
 static void patch_stats(struct patch *patch)
 {
 	int lines = patch->lines_added + patch->lines_deleted;
@@ -1011,8 +1194,151 @@ 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_subdirectories(const char *path)
+{
+	int len = strlen(path);
+	char *buf = xmalloc(len + 1);
+	const char *slash = path;
+
+	while ((slash = strchr(slash+1, '/')) != NULL) {
+		len = slash - path;
+		memcpy(buf, path, len);
+		buf[len] = 0;
+		if (mkdir(buf, 0755) < 0) {
+			if (errno != EEXIST)
+				break;
+		}
+	}
+	free(buf);
+}
+
+/*
+ * We optimistically assume that the directories exist,
+ * which is true 99% of the time anyway. If they don't,
+ * we create them and try again.
+ */
+static int create_regular_file(const char *path, unsigned int mode)
+{
+	int ret = open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
+
+	if (ret < 0 && errno == ENOENT) {
+		create_subdirectories(path);
+		ret = open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
+	}
+	return ret;
+}
+
+static int create_symlink(const char *buf, const char *path)
+{
+	int ret = symlink(buf, path);
+
+	if (ret < 0 && errno == ENOENT) {
+		create_subdirectories(path);
+		ret = symlink(buf, path);
+	}
+	return ret;
+}
+
+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 = create_regular_file(path, 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 (create_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;
@@ -1036,15 +1362,36 @@ static int apply_patch(int fd)
 		size -= nr;
 	}
 
+	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);
 
+	if (summary)
+		summary_patch_list(list);
+
 	free(buffer);
 	return 0;
 }
@@ -1054,9 +1401,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;
@@ -1075,6 +1419,11 @@ int main(int argc, char **argv)
 			diffstat = 1;
 			continue;
 		}
+		if (!strcmp(arg, "--summary")) {
+			apply = 0;
+			summary = 1;
+			continue;
+		}
 		if (!strcmp(arg, "--check")) {
 			apply = 0;
 			check = 1;
@@ -1084,6 +1433,10 @@ int main(int argc, char **argv)
 			check_index = 1;
 			continue;
 		}
+		if (!strcmp(arg, "--apply")) {
+			apply = 1;
+			continue;
+		}
 		if (!strcmp(arg, "--show-files")) {
 			show_files = 1;
 			continue;