X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=apply.c;h=964df2db10c22d6ed0b89532e0af8cf9a43e607c;hb=edde7a8b5324d88f07fcb8204da313c19b4988fa;hp=195acdbc2125cc3fccd01263051e66a6f73b91a5;hpb=6e7c92a91d2706ddd9955cb9807b65a63b0bbfdf;p=git.git diff --git a/apply.c b/apply.c index 195acdbc..964df2db 100644 --- a/apply.c +++ b/apply.c @@ -13,7 +13,7 @@ * uses the working tree as a "branch" for a 3-way merge. */ #include - +#include #include "cache.h" // We default to the merge behaviour, since that's what most people would @@ -26,11 +26,14 @@ // 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] "; +static const char apply_usage[] = +"git-apply [--no-merge] [--stat] [--summary] [--check] [--index] [--apply] [--show-files] ..."; /* * For "diff-stat" like behaviour, we keep track of the biggest change @@ -59,8 +62,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 +332,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; } @@ -379,7 +387,7 @@ static char *git_header_name(char *line) default: continue; case '\n': - break; + return NULL; case '\t': case ' ': second = name+len; for (;;) { @@ -434,6 +442,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 }, @@ -553,7 +563,7 @@ static int find_header(char *line, unsigned long size, int *hdrsize, struct patc 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); + error("patch fragment without header at line %d: %.*s", linenr, (int)len-1, line); } if (size < len + 6) @@ -565,10 +575,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 +619,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 +627,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; @@ -645,13 +672,24 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s added++; newlines--; break; - /* We allow "\ No newline at end of file" */ + + /* We allow "\ No newline at end of file". Depending + * on locale settings when the patch was produced we + * don't know what this line looks like. The only + * thing we do know is that it begins with "\ ". */ case '\\': - if (len < 12 || memcmp(line, "\\ No newline", 12)) + if (len < 12 || memcmp(line, "\\ ", 2)) return -1; break; } } + /* If a fragment ends with an incomplete line, we failed to include + * it in the above loop because we hit oldlines == newlines == 0 + * before seeing it. + */ + if (12 < size && !memcmp(line, "\\ ", 2)) + offset += linelen(line, size); + patch->lines_added += added; patch->lines_deleted += deleted; return offset; @@ -698,16 +736,17 @@ static int parse_chunk(char *buffer, unsigned long size, struct patch *patch) return offset + hdrsize + patchsize; } -const char pluses[] = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"; -const char minuses[]= "----------------------------------------------------------------------"; +static const char pluses[] = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"; +static const char minuses[]= "----------------------------------------------------------------------"; static void show_stats(struct patch *patch) { - char *name = patch->old_name; + const char *prefix = ""; + char *name = patch->new_name; int len, max, add, del, total; if (!name) - name = patch->new_name; + name = patch->old_name; /* * "scale" the filename @@ -716,8 +755,15 @@ static void show_stats(struct patch *patch) max = max_len; if (max > 50) max = 50; - if (len > max) + if (len > max) { + char *slash; + prefix = "..."; + max -= 3; name += len - max; + slash = strchr(name, '/'); + if (slash) + name = slash; + } len = max; /* @@ -731,10 +777,12 @@ 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; - printf(" %-*s |%5d %.*s%.*s\n", + 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%-*s |%5d %.*s%.*s\n", prefix, len, name, patch->lines_added + patch->lines_deleted, add, pluses, del, minuses); } @@ -832,7 +880,6 @@ static int find_offset(const char *buf, unsigned long size, const char *fragment n = (i >> 1)+1; if (i & 1) n = -n; - fprintf(stderr, "Fragment applied at offset %d\n", n); return try; } @@ -872,7 +919,7 @@ static int apply_one_fragment(struct buffer_desc *desc, struct fragment *frag) * last one (which is the newline, of course). */ plen = len-1; - if (len > size && patch[len] == '\\') + if (len < size && patch[len] == '\\') plen--; switch (*patch) { case ' ': @@ -925,9 +972,10 @@ static int apply_fragments(struct buffer_desc *desc, struct patch *patch) while (frag) { if (apply_one_fragment(desc, frag) < 0) - return error("patch failed: %s:%d", patch->old_name, frag->oldpos); + return error("patch failed: %s:%ld", patch->old_name, frag->oldpos); frag = frag->next; } + return 0; } static int apply_data(struct patch *patch, struct stat *st) @@ -936,13 +984,16 @@ static int apply_data(struct patch *patch, struct stat *st) unsigned long size, alloc; struct buffer_desc desc; - if (!patch->old_name || !patch->fragments) - return 0; - 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); + 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; @@ -951,6 +1002,10 @@ static int apply_data(struct patch *patch, struct stat *st) 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; } @@ -964,7 +1019,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) @@ -975,6 +1030,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) @@ -991,6 +1047,12 @@ 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) { + if (patch->is_new) + patch->new_mode = S_IFREG | 0644; + else + patch->new_mode = patch->old_mode; + } } if (new_name && old_name) { @@ -1060,6 +1122,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, + (int)(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; @@ -1078,11 +1218,186 @@ 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, 0777) < 0) { + if (errno != EEXIST) + break; + } + } + free(buf); +} + +static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size) +{ + int fd; + + if (S_ISLNK(mode)) + return symlink(buf, path); + fd = open(path, O_CREAT | O_EXCL | O_WRONLY | O_TRUNC, (mode & 0100) ? 0777 : 0666); + if (fd < 0) + return -1; + while (size) { + int written = write(fd, buf, size); + if (written < 0) { + if (errno == EINTR || errno == EAGAIN) + continue; + die("writing file %s: %s", path, strerror(errno)); + } + if (!written) + die("out of space writing file %s", path); + buf += written; + size -= written; + } + if (close(fd) < 0) + die("closing file %s: %s", path, strerror(errno)); + return 0; +} + +/* + * 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 void create_one_file(const char *path, unsigned mode, const char *buf, unsigned long size) +{ + if (!try_create_file(path, mode, buf, size)) + return; + + if (errno == ENOENT) { + create_subdirectories(path); + if (!try_create_file(path, mode, buf, size)) + return; + } + + if (errno == EEXIST) { + unsigned int nr = getpid(); + + for (;;) { + const char *newpath; + newpath = mkpath("%s~%u", path, nr); + if (!try_create_file(newpath, mode, buf, size)) { + if (!rename(newpath, path)) + return; + unlink(newpath); + break; + } + if (errno != EEXIST) + break; + } + } + die("unable to write file %s mode %o", path, mode); +} + +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; + create_one_file(path, mode, buf, size); + add_index_file(path, mode, buf, size); +} + +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, int skipped_patch) +{ + if (!list && !skipped_patch) + die("No changes"); + + while (list) { + write_out_one_result(list); + list = list->next; + } +} + +static struct cache_file cache_file; + +static struct excludes { + struct excludes *next; + const char *path; +} *excludes; + +static int use_patch(struct patch *p) +{ + const char *pathname = p->new_name ? p->new_name : p->old_name; + struct excludes *x = excludes; + while (x) { + if (fnmatch(x->path, pathname, 0) == 0) + return 0; + x = x->next; + } + return 1; +} + 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; + int skipped_patch = 0; if (!buffer) return -1; @@ -1096,22 +1411,49 @@ static int apply_patch(int fd) nr = parse_chunk(buffer + offset, size, patch); if (nr < 0) break; - patch_stats(patch); - *listp = patch; - listp = &patch->next; + if (use_patch(patch)) { + patch_stats(patch); + *listp = patch; + listp = &patch->next; + } else { + /* perhaps free it a bit better? */ + free(patch); + skipped_patch++; + } 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, skipped_patch); + + 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; } @@ -1121,9 +1463,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; @@ -1133,6 +1472,14 @@ int main(int argc, char **argv) read_stdin = 0; continue; } + if (!strncmp(arg, "--exclude=", 10)) { + struct excludes *x = xmalloc(sizeof(*x)); + x->path = arg + 10; + x->next = excludes; + excludes = x; + continue; + } + /* NEEDSWORK: this does not do anything at this moment. */ if (!strcmp(arg, "--no-merge")) { merge_patch = 0; continue; @@ -1142,6 +1489,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; @@ -1151,6 +1503,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;