X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=apply.c;h=c81b0a240a38b57a9bbd2586889304bef8f5cbbf;hb=f65fdf04a13d2252de8b2b4b161db7c43f2c28ad;hp=4f3ac90c94761ee3e49b22f66650e88a2b872781;hpb=30996652e752d5fdf18f6978a70905747d1fdabc;p=git.git diff --git a/apply.c b/apply.c index 4f3ac90c..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] "; +static const char apply_usage[] = "git-apply [--stat] [--summary] [--check] [--show-files] "; /* * 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; } @@ -627,8 +639,11 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s 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"); + 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; @@ -714,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 @@ -742,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); @@ -843,7 +860,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; } @@ -966,6 +982,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; } @@ -979,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) @@ -990,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) @@ -1006,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) { @@ -1075,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; @@ -1093,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; @@ -1118,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; } @@ -1136,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; @@ -1157,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; @@ -1166,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;