* uses the working tree as a "branch" for a 3-way merge.
*/
#include <ctype.h>
-
+#include <fnmatch.h>
#include "cache.h"
// We default to the merge behaviour, since that's what most people would
static int check = 0;
static int apply = 1;
static int show_files = 0;
-static const char apply_usage[] = "git-apply [--stat] [--summary] [--check] [--show-files] <patch>";
+static const char apply_usage[] =
+"git-apply [--no-merge] [--stat] [--summary] [--check] [--index] [--apply] [--show-files] <patch>...";
/*
* For "diff-stat" like behaviour, we keep track of the biggest change
default:
continue;
case '\n':
- break;
+ return NULL;
case '\t': case ' ':
second = name+len;
for (;;) {
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)
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;
static void show_stats(struct patch *patch)
{
+ const char *prefix = "";
char *name = patch->new_name;
int len, max, add, del, total;
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;
/*
add = (add * max + max_change / 2) / max_change;
del = total - add;
}
- printf(" %-*s |%5d %.*s%.*s\n",
+ printf(" %s%-*s |%5d %.*s%.*s\n", prefix,
len, name, patch->lines_added + patch->lines_deleted,
add, pluses, del, minuses);
}
* 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 ' ':
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;
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 (!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) {
*/
if (old != p->old_name)
printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,
- old - p->old_name, p->old_name,
+ (int)(old - p->old_name), p->old_name,
old, new, p->score);
else
printf(" %s %s => %s (%d%%)\n", renamecopy,
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 int create_regular_file(const char *path, unsigned int mode)
+static void create_one_file(const char *path, unsigned mode, const char *buf, unsigned long size)
{
- int ret = open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
+ if (!try_create_file(path, mode, buf, size))
+ return;
- if (ret < 0 && errno == ENOENT) {
+ if (errno == ENOENT) {
create_subdirectories(path);
- ret = open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
+ if (!try_create_file(path, mode, buf, size))
+ return;
}
- return ret;
-}
-static int create_symlink(const char *buf, const char *path)
-{
- int ret = symlink(buf, path);
+ if (errno == EEXIST) {
+ unsigned int nr = getpid();
- if (ret < 0 && errno == ENOENT) {
- create_subdirectories(path);
- ret = symlink(buf, path);
+ 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;
+ }
}
- return ret;
+ die("unable to write file %s mode %o", path, mode);
}
static void create_file(struct patch *patch)
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);
+ create_one_file(path, mode, buf, size);
+ add_index_file(path, mode, buf, size);
}
static void write_out_one_result(struct patch *patch)
create_file(patch);
}
-static void write_out_results(struct patch *list)
+static void write_out_results(struct patch *list, int skipped_patch)
{
- if (!list)
+ if (!list && !skipped_patch)
die("No changes");
while (list) {
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;
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;
}
exit(1);
if (apply)
- write_out_results(list);
+ write_out_results(list, skipped_patch);
if (write_index) {
if (write_cache(newfd, active_cache, active_nr) ||
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;
projects / git.git / blobdiff