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

diff --git a/apply.c b/apply.c
index 85d7965d..1f48ef90 100644
--- a/apply.c
+++ b/apply.c
@@ -17,11 +17,57 @@
 #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 const char apply_usage[] = "git-apply <patch>";
+static int check_index = 0;
+static int write_index = 0;
+static int diffstat = 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>";
+
+/*
+ * For "diff-stat" like behaviour, we keep track of the biggest change
+ * we've seen, and the longest filename. That allows us to do simple
+ * scaling.
+ */
+static int max_change, max_len;
+
+/*
+ * Various "current state", notably line numbers and what
+ * file (and how) we're patching right now.. The "is_xxxx"
+ * things are flags, where -1 means "don't know yet".
+ */
+static int linenr = 1;
+
+struct fragment {
+	unsigned long oldpos, oldlines;
+	unsigned long newpos, newlines;
+	const char *patch;
+	int size;
+	struct fragment *next;
+};
+
+struct patch {
+	char *new_name, *old_name, *def_name;
+	unsigned int old_mode, new_mode;
+	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;
+};
 
 #define CHUNKSIZE (8192)
+#define SLOP (16)
 
 static void *read_patch_file(int fd, unsigned long *sizep)
 {
@@ -46,10 +92,19 @@ static void *read_patch_file(int fd, unsigned long *sizep)
 		size += nr;
 	}
 	*sizep = size;
+
+	/*
+	 * Make sure that we have some slop in the buffer
+	 * so that we can do speculative "memcmp" etc, and
+	 * see to it that it is NUL-filled.
+	 */
+	if (alloc < size + SLOP)
+		buffer = xrealloc(buffer, size + SLOP);
+	memset(buffer + size, 0, SLOP);
 	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--) {
@@ -60,55 +115,428 @@ static unsigned long linelen(char *buffer, unsigned long size)
 	return len;
 }
 
-static int match_word(const char *line, const char *match)
+static int is_dev_null(const char *str)
+{
+	return !memcmp("/dev/null", str, 9) && isspace(str[9]);
+}
+
+#define TERM_SPACE	1
+#define TERM_TAB	2
+
+static int name_terminate(const char *name, int namelen, int c, int terminate)
+{
+	if (c == ' ' && !(terminate & TERM_SPACE))
+		return 0;
+	if (c == '\t' && !(terminate & TERM_TAB))
+		return 0;
+
+	return 1;
+}
+
+static char * find_name(const char *line, char *def, int p_value, int terminate)
+{
+	int len;
+	const char *start = line;
+	char *name;
+
+	for (;;) {
+		char c = *line;
+
+		if (isspace(c)) {
+			if (c == '\n')
+				break;
+			if (name_terminate(start, line-start, c, terminate))
+				break;
+		}
+		line++;
+		if (c == '/' && !--p_value)
+			start = line;
+	}
+	if (!start)
+		return def;
+	len = line - start;
+	if (!len)
+		return def;
+
+	/*
+	 * Generally we prefer the shorter name, especially
+	 * if the other one is just a variation of that with
+	 * something else tacked on to the end (ie "file.orig"
+	 * or "file~").
+	 */
+	if (def) {
+		int deflen = strlen(def);
+		if (deflen < len && !strncmp(start, def, deflen))
+			return def;
+	}
+
+	name = xmalloc(len + 1);
+	memcpy(name, start, len);
+	name[len] = 0;
+	free(def);
+	return name;
+}
+
+/*
+ * Get the name etc info from the --/+++ lines of a traditional patch header
+ *
+ * NOTE! This hardcodes "-p1" behaviour in filename detection.
+ *
+ * FIXME! The end-of-filename heuristics are kind of screwy. For existing
+ * files, we can happily check the index for a match, but for creating a
+ * new file we should try to match whatever "patch" does. I have no idea.
+ */
+static void parse_traditional_patch(const char *first, const char *second, struct patch *patch)
+{
+	int p_value = 1;
+	char *name;
+
+	first += 4;	// skip "--- "
+	second += 4;	// skip "+++ "
+	if (is_dev_null(first)) {
+		patch->is_new = 1;
+		patch->is_delete = 0;
+		name = find_name(second, NULL, p_value, TERM_SPACE | TERM_TAB);
+		patch->new_name = name;
+	} else if (is_dev_null(second)) {
+		patch->is_new = 0;
+		patch->is_delete = 1;
+		name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
+		patch->old_name = name;
+	} else {
+		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)
+		die("unable to find filename in patch at line %d", linenr);
+}
+
+static int gitdiff_hdrend(const char *line, struct patch *patch)
+{
+	return -1;
+}
+
+/*
+ * We're anal about diff header consistency, to make
+ * sure that we don't end up having strange ambiguous
+ * patches floating around.
+ *
+ * As a result, gitdiff_{old|new}name() will check
+ * their names against any previous information, just
+ * to make sure..
+ */
+static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name, const char *oldnew)
+{
+	int len;
+	const char *name;
+
+	if (!orig_name && !isnull)
+		return find_name(line, NULL, 1, 0);
+
+	name = "/dev/null";
+	len = 9;
+	if (orig_name) {
+		name = orig_name;
+		len = strlen(name);
+		if (isnull)
+			die("git-apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr);
+	}
+
+	if (*name == '/')
+		goto absolute_path;
+
+	for (;;) {
+		char c = *line++;
+		if (c == '\n')
+			break;
+		if (c != '/')
+			continue;
+absolute_path:
+		if (memcmp(line, name, len) || line[len] != '\n')
+			break;
+		return orig_name;
+	}
+	die("git-apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr);
+	return NULL;
+}
+
+static int gitdiff_oldname(const char *line, struct patch *patch)
+{
+	patch->old_name = gitdiff_verify_name(line, patch->is_new, patch->old_name, "old");
+	return 0;
+}
+
+static int gitdiff_newname(const char *line, struct patch *patch)
+{
+	patch->new_name = gitdiff_verify_name(line, patch->is_delete, patch->new_name, "new");
+	return 0;
+}
+
+static int gitdiff_oldmode(const char *line, struct patch *patch)
+{
+	patch->old_mode = strtoul(line, NULL, 8);
+	return 0;
+}
+
+static int gitdiff_newmode(const char *line, struct patch *patch)
+{
+	patch->new_mode = strtoul(line, NULL, 8);
+	return 0;
+}
+
+static int gitdiff_delete(const char *line, struct patch *patch)
+{
+	patch->is_delete = 1;
+	patch->old_name = patch->def_name;
+	return gitdiff_oldmode(line, patch);
+}
+
+static int gitdiff_newfile(const char *line, struct patch *patch)
+{
+	patch->is_new = 1;
+	patch->new_name = patch->def_name;
+	return gitdiff_newmode(line, patch);
+}
+
+static int gitdiff_copysrc(const char *line, struct patch *patch)
+{
+	patch->is_copy = 1;
+	patch->old_name = find_name(line, NULL, 0, 0);
+	return 0;
+}
+
+static int gitdiff_copydst(const char *line, struct patch *patch)
+{
+	patch->is_copy = 1;
+	patch->new_name = find_name(line, NULL, 0, 0);
+	return 0;
+}
+
+static int gitdiff_renamesrc(const char *line, struct patch *patch)
+{
+	patch->is_rename = 1;
+	patch->old_name = find_name(line, NULL, 0, 0);
+	return 0;
+}
+
+static int gitdiff_renamedst(const char *line, struct patch *patch)
+{
+	patch->is_rename = 1;
+	patch->new_name = find_name(line, NULL, 0, 0);
+	return 0;
+}
+
+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.
+ */
+static int gitdiff_unrecognized(const char *line, struct patch *patch)
 {
+	return -1;
+}
+
+static char *git_header_name(char *line)
+{
+	int len;
+	char *name, *second;
+
+	/*
+	 * Find the first '/'
+	 */
+	name = line;
 	for (;;) {
-		char c = *match++;
-		if (!c)
+		char c = *name++;
+		if (c == '\n')
+			return NULL;
+		if (c == '/')
+			break;
+	}
+
+	/*
+	 * We don't accept absolute paths (/dev/null) as possibly valid
+	 */
+	if (name == line+1)
+		return NULL;
+
+	/*
+	 * Accept a name only if it shows up twice, exactly the same
+	 * form.
+	 */
+	for (len = 0 ; ; len++) {
+		char c = name[len];
+
+		switch (c) {
+		default:
+			continue;
+		case '\n':
 			break;
-		if (*line++ != c)
-			return 0;
+		case '\t': case ' ':
+			second = name+len;
+			for (;;) {
+				char c = *second++;
+				if (c == '\n')
+					return NULL;
+				if (c == '/')
+					break;
+			}
+			if (second[len] == '\n' && !memcmp(name, second, len)) {
+				char *ret = xmalloc(len + 1);
+				memcpy(ret, name, len);
+				ret[len] = 0;
+				return ret;
+			}
+		}
 	}
-	return *line == ' ';
+	return NULL;
 }
 
 /* Verify that we recognize the lines following a git header */
-static int parse_git_header(char *line, unsigned int size)
+static int parse_git_header(char *line, int len, unsigned int size, struct patch *patch)
 {
-	unsigned long offset, len;
+	unsigned long offset;
+
+	/* A git diff has explicit new/delete information, so we don't guess */
+	patch->is_new = 0;
+	patch->is_delete = 0;
+
+	/*
+	 * Some things may not have the old name in the
+	 * rest of the headers anywhere (pure mode changes,
+	 * or removing or adding empty files), so we get
+	 * the default name from the header.
+	 */
+	patch->def_name = git_header_name(line + strlen("diff --git "));
+
+	line += len;
+	size -= len;
+	linenr++;
+	for (offset = len ; size > 0 ; offset += len, size -= len, line += len, linenr++) {
+		static const struct opentry {
+			const char *str;
+			int (*fn)(const char *, struct patch *);
+		} optable[] = {
+			{ "@@ -", gitdiff_hdrend },
+			{ "--- ", gitdiff_oldname },
+			{ "+++ ", gitdiff_newname },
+			{ "old mode ", gitdiff_oldmode },
+			{ "new mode ", gitdiff_newmode },
+			{ "deleted file mode ", gitdiff_delete },
+			{ "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;
 
-	for (offset = 0 ; size > 0 ; offset += len, size -= len, line += len) {
 		len = linelen(line, size);
-		if (!len)
+		if (!len || line[len-1] != '\n')
 			break;
-		if (line[len-1] != '\n')
-			return -1;
-		if (len < 4)
+		for (i = 0; i < sizeof(optable) / sizeof(optable[0]); i++) {
+			const struct opentry *p = optable + i;
+			int oplen = strlen(p->str);
+			if (len < oplen || memcmp(p->str, line, oplen))
+				continue;
+			if (p->fn(line + oplen, patch) < 0)
+				return offset;
 			break;
-		if (!memcmp(line, "@@ -", 4))
-			return offset;
-		if (match_word(line, "new file mode"))
-			continue;
-		if (match_word(line, "deleted file mode"))
-			continue;
-		if (match_word(line, "copy"))
-			continue;
-		if (match_word(line, "rename"))
-			continue;
-		if (match_word(line, "similarity index"))
-			continue;
-		break;
+		}
 	}
 
-	/* We want either a patch _or_ something real */
-	return offset ? :-1;
+	return offset;
 }
 
-static int find_header(char *line, unsigned long size, int *hdrsize)
+static int parse_num(const char *line, unsigned long *p)
+{
+	char *ptr;
+
+	if (!isdigit(*line))
+		return 0;
+	*p = strtoul(line, &ptr, 10);
+	return ptr - line;
+}
+
+static int parse_range(const char *line, int len, int offset, const char *expect,
+			unsigned long *p1, unsigned long *p2)
+{
+	int digits, ex;
+
+	if (offset < 0 || offset >= len)
+		return -1;
+	line += offset;
+	len -= offset;
+
+	digits = parse_num(line, p1);
+	if (!digits)
+		return -1;
+
+	offset += digits;
+	line += digits;
+	len -= digits;
+
+	*p2 = *p1;
+	if (*line == ',') {
+		digits = parse_num(line+1, p2);
+		if (!digits)
+			return -1;
+
+		offset += digits+1;
+		line += digits+1;
+		len -= digits+1;
+	}
+
+	ex = strlen(expect);
+	if (ex > len)
+		return -1;
+	if (memcmp(line, expect, ex))
+		return -1;
+
+	return offset + ex;
+}
+
+/*
+ * Parse a unified diff fragment header of the
+ * form "@@ -a,b +c,d @@"
+ */
+static int parse_fragment_header(char *line, int len, struct fragment *fragment)
+{
+	int offset;
+
+	if (!len || line[len-1] != '\n')
+		return -1;
+
+	/* Figure out the number of lines in a fragment */
+	offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);
+	offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);
+
+	return offset;
+}
+
+static int find_header(char *line, unsigned long size, int *hdrsize, struct patch *patch)
 {
 	unsigned long offset, len;
 
-	for (offset = 0; size > 0; offset += len, size -= len, line += len) {
+	patch->is_rename = patch->is_copy = 0;
+	patch->is_new = patch->is_delete = -1;
+	patch->old_mode = patch->new_mode = 0;
+	patch->old_name = patch->new_name = NULL;
+	for (offset = 0; size > 0; offset += len, size -= len, line += len, linenr++) {
 		unsigned long nextlen;
 
 		len = linelen(line, size);
@@ -118,6 +546,19 @@ static int find_header(char *line, unsigned long size, int *hdrsize)
 		/* Testing this early allows us to take a few shortcuts.. */
 		if (len < 6)
 			continue;
+
+		/*
+		 * Make sure we don't find any unconnected patch fragmants.
+		 * That's a sign that we didn't find a header, and that a
+		 * patch has become corrupted/broken up.
+		 */
+		if (!memcmp("@@ -", line, 4)) {
+			struct fragment dummy;
+			if (parse_fragment_header(line, len, &dummy) < 0)
+				continue;
+			error("patch fragment without header at line %d: %.*s", linenr, len-1, line);
+		}
+
 		if (size < len + 6)
 			break;
 
@@ -126,11 +567,12 @@ static int find_header(char *line, unsigned long size, int *hdrsize)
 		 * or mode change, so we handle that specially
 		 */
 		if (!memcmp("diff --git ", line, 11)) {
-			int git_hdr_len = parse_git_header(line + len, size - len);
+			int git_hdr_len = parse_git_header(line, len, size, patch);
 			if (git_hdr_len < 0)
 				continue;
-
-			*hdrsize = len + git_hdr_len;
+			if (!patch->old_name && !patch->new_name)
+				die("git diff header lacks filename information (line %d)", linenr);
+			*hdrsize = git_hdr_len;
 			return offset;
 		}
 
@@ -148,41 +590,14 @@ static int find_header(char *line, unsigned long size, int *hdrsize)
 			continue;
 
 		/* Ok, we'll consider it a patch */
+		parse_traditional_patch(line, line+len, patch);
 		*hdrsize = len + nextlen;
+		linenr += 2;
 		return offset;
 	}
 	return -1;
 }
 
-static int parse_num(const char *line, int len, int offset, const char *expect, unsigned long *p)
-{
-	char *ptr;
-	int digits, ex;
-
-	if (offset < 0 || offset >= len)
-		return -1;
-	line += offset;
-	len -= offset;
-
-	if (!isdigit(*line))
-		return -1;
-	*p = strtoul(line, &ptr, 10);
-
-	digits = ptr - line;
-
-	offset += digits;
-	line += digits;
-	len -= digits;
-
-	ex = strlen(expect);
-	if (ex > len)
-		return -1;
-	if (memcmp(line, expect, ex))
-		return -1;
-
-	return offset + ex;
-}
-
 /*
  * Parse a unified diff. Note that this really needs
  * to parse each fragment separately, since the only
@@ -190,26 +605,40 @@ static int parse_num(const char *line, int len, int offset, const char *expect,
  * part of a patch, and a "---" that starts the next
  * patch is to look at the line counts..
  */
-static int apply_fragment(char *line, unsigned long size)
+static int parse_fragment(char *line, unsigned long size, struct patch *patch, struct fragment *fragment)
 {
+	int added, deleted;
 	int len = linelen(line, size), offset;
-	unsigned long oldpos, oldlines, newpos, newlines;
-
-	if (!len || line[len-1] != '\n')
-		return -1;
+	unsigned long oldlines, newlines;
 
-	/* Figure out the number of lines in a fragment */
-	offset = parse_num(line, len, 4, ",", &oldpos);
-	offset = parse_num(line, len, offset, " +", &oldlines);
-	offset = parse_num(line, len, offset, ",", &newpos);
-	offset = parse_num(line, len, offset, " @@", &newlines);
+	offset = parse_fragment_header(line, len, fragment);
 	if (offset < 0)
 		return -1;
+	oldlines = fragment->oldlines;
+	newlines = fragment->newlines;
+
+	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;
 	size -= len;
-	for (offset = len; size > 0; offset += len, size -= len, line += len) {
+	linenr++;
+	added = deleted = 0;
+	for (offset = len; size > 0; offset += len, size -= len, line += len, linenr++) {
 		if (!oldlines && !newlines)
 			break;
 		len = linelen(line, size);
@@ -223,26 +652,45 @@ static int apply_fragment(char *line, unsigned long size)
 			newlines--;
 			break;
 		case '-':
+			deleted++;
 			oldlines--;
 			break;
 		case '+':
+			added++;
 			newlines--;
 			break;
+		/* We allow "\ No newline at end of file" */
+		case '\\':
+			if (len < 12 || memcmp(line, "\\ No newline", 12))
+				return -1;
+			break;
 		}
 	}
+	patch->lines_added += added;
+	patch->lines_deleted += deleted;
 	return offset;
 }
 
-static int apply_single_patch(char *line, unsigned long size)
+static int parse_single_patch(char *line, unsigned long size, struct patch *patch)
 {
 	unsigned long offset = 0;
+	struct fragment **fragp = &patch->fragments;
 
 	while (size > 4 && !memcmp(line, "@@ -", 4)) {
-		int len = apply_fragment(line, size);
+		struct fragment *fragment;
+		int len;
+
+		fragment = xmalloc(sizeof(*fragment));
+		memset(fragment, 0, sizeof(*fragment));
+		len = parse_fragment(line, size, patch, fragment);
 		if (len <= 0)
-			break;
+			die("corrupt patch at line %d", linenr);
+
+		fragment->patch = line;
+		fragment->size = len;
 
-printf("applying fragment:\n%.*s\n\n", len, line);
+		*fragp = fragment;
+		fragp = &fragment->next;
 
 		offset += len;
 		line += len;
@@ -251,39 +699,559 @@ printf("applying fragment:\n%.*s\n\n", len, line);
 	return offset;
 }
 
-static int apply_chunk(char *buffer, unsigned long size)
+static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
 {
 	int hdrsize, patchsize;
-	int offset = find_header(buffer, size, &hdrsize);
-	char *header, *patch;
+	int offset = find_header(buffer, size, &hdrsize, patch);
 
 	if (offset < 0)
 		return offset;
-	header = buffer + offset;
 
-printf("Found header:\n%.*s\n\n", hdrsize, header);
-
-	patch = header + hdrsize;
-	patchsize = apply_single_patch(patch, size - offset - hdrsize);
+	patchsize = parse_single_patch(buffer + offset + hdrsize, size - offset - hdrsize, patch);
 
 	return offset + hdrsize + patchsize;
 }
 
+const char pluses[] = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
+const char minuses[]= "----------------------------------------------------------------------";
+
+static void show_stats(struct patch *patch)
+{
+	char *name = patch->old_name;
+	int len, max, add, del, total;
+
+	if (!name)
+		name = patch->new_name;
+
+	/*
+	 * "scale" the filename
+	 */
+	len = strlen(name);
+	max = max_len;
+	if (max > 50)
+		max = 50;
+	if (len > max)
+		name += len - max;
+	len = max;
+
+	/*
+	 * scale the add/delete
+	 */
+	max = max_change;
+	if (max + len > 70)
+		max = 70 - len;
+
+	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 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) {
+		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 (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 int check_patch_list(struct patch *patch)
+{
+	int error = 0;
+
+	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;
+		}
+		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);
+	}
+}
+
+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)
+{
+	int lines = patch->lines_added + patch->lines_deleted;
+
+	if (lines > max_change)
+		max_change = lines;
+	if (patch->old_name) {
+		int len = strlen(patch->old_name);
+		if (len > max_len)
+			max_len = len;
+	}
+	if (patch->new_name) {
+		int len = strlen(patch->new_name);
+		if (len > max_len)
+			max_len = len;
+	}
+}
+
+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;
 
 	if (!buffer)
 		return -1;
 	offset = 0;
 	while (size > 0) {
-		int nr = apply_chunk(buffer + offset, size);
+		struct patch *patch;
+		int nr;
+
+		patch = xmalloc(sizeof(*patch));
+		memset(patch, 0, sizeof(*patch));
+		nr = parse_chunk(buffer + offset, size, patch);
 		if (nr < 0)
 			break;
+		patch_stats(patch);
+		*listp = patch;
+		listp = &patch->next;
 		offset += nr;
 		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);
+
 	free(buffer);
 	return 0;
 }
@@ -291,9 +1259,7 @@ static int apply_patch(int fd)
 int main(int argc, char **argv)
 {
 	int i;
-
-	if (read_cache() < 0)
-		die("unable to read index file");
+	int read_stdin = 1;
 
 	for (i = 1; i < argc; i++) {
 		const char *arg = argv[i];
@@ -301,17 +1267,39 @@ int main(int argc, char **argv)
 
 		if (!strcmp(arg, "-")) {
 			apply_patch(0);
+			read_stdin = 0;
 			continue;
 		}
 		if (!strcmp(arg, "--no-merge")) {
 			merge_patch = 0;
 			continue;
 		}
+		if (!strcmp(arg, "--stat")) {
+			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);
+		read_stdin = 0;
 		apply_patch(fd);
 		close(fd);
 	}
+	if (read_stdin)
+		apply_patch(0);
 	return 0;
 }