#include "cache.h"
-#include "path-list.h"
+#include "string-list.h"
#include "rerere.h"
#include "xdiff/xdiff.h"
#include "xdiff-interface.h"
return !stat(rr_path(name, "postimage"), &st);
}
-static void read_rr(struct path_list *rr)
+static void read_rr(struct string_list *rr)
{
unsigned char sha1[20];
char buf[PATH_MAX];
; /* do nothing */
if (i == sizeof(buf))
die("filename too long");
- path_list_insert(buf, rr)->util = name;
+ string_list_insert(buf, rr)->util = name;
}
fclose(in);
}
static struct lock_file write_lock;
-static int write_rr(struct path_list *rr, int out_fd)
+static int write_rr(struct string_list *rr, int out_fd)
{
int i;
for (i = 0; i < rr->nr; i++) {
int length;
if (!rr->items[i].util)
continue;
- path = rr->items[i].path;
+ path = rr->items[i].string;
length = strlen(path) + 1;
if (write_in_full(out_fd, rr->items[i].util, 40) != 40 ||
write_in_full(out_fd, "\t", 1) != 1 ||
return 0;
}
+static void ferr_write(const void *p, size_t count, FILE *fp, int *err)
+{
+ if (!count || *err)
+ return;
+ if (fwrite(p, count, 1, fp) != 1)
+ *err = errno;
+}
+
+static inline void ferr_puts(const char *s, FILE *fp, int *err)
+{
+ ferr_write(s, strlen(s), fp, err);
+}
+
static int handle_file(const char *path,
unsigned char *sha1, const char *output)
{
- SHA_CTX ctx;
+ git_SHA_CTX ctx;
char buf[1024];
- int hunk = 0, hunk_no = 0;
- struct strbuf one, two;
+ int hunk_no = 0;
+ enum {
+ RR_CONTEXT = 0, RR_SIDE_1, RR_SIDE_2, RR_ORIGINAL,
+ } hunk = RR_CONTEXT;
+ struct strbuf one = STRBUF_INIT, two = STRBUF_INIT;
FILE *f = fopen(path, "r");
FILE *out = NULL;
+ int wrerror = 0;
if (!f)
return error("Could not open %s", path);
}
if (sha1)
- SHA1_Init(&ctx);
+ git_SHA1_Init(&ctx);
- strbuf_init(&one, 0);
- strbuf_init(&two, 0);
while (fgets(buf, sizeof(buf), f)) {
if (!prefixcmp(buf, "<<<<<<< ")) {
- if (hunk)
+ if (hunk != RR_CONTEXT)
+ goto bad;
+ hunk = RR_SIDE_1;
+ } else if (!prefixcmp(buf, "|||||||") && isspace(buf[7])) {
+ if (hunk != RR_SIDE_1)
goto bad;
- hunk = 1;
+ hunk = RR_ORIGINAL;
} else if (!prefixcmp(buf, "=======") && isspace(buf[7])) {
- if (hunk != 1)
+ if (hunk != RR_SIDE_1 && hunk != RR_ORIGINAL)
goto bad;
- hunk = 2;
+ hunk = RR_SIDE_2;
} else if (!prefixcmp(buf, ">>>>>>> ")) {
- if (hunk != 2)
+ if (hunk != RR_SIDE_2)
goto bad;
if (strbuf_cmp(&one, &two) > 0)
strbuf_swap(&one, &two);
hunk_no++;
- hunk = 0;
+ hunk = RR_CONTEXT;
if (out) {
- fputs("<<<<<<<\n", out);
- fwrite(one.buf, one.len, 1, out);
- fputs("=======\n", out);
- fwrite(two.buf, two.len, 1, out);
- fputs(">>>>>>>\n", out);
+ ferr_puts("<<<<<<<\n", out, &wrerror);
+ ferr_write(one.buf, one.len, out, &wrerror);
+ ferr_puts("=======\n", out, &wrerror);
+ ferr_write(two.buf, two.len, out, &wrerror);
+ ferr_puts(">>>>>>>\n", out, &wrerror);
}
if (sha1) {
- SHA1_Update(&ctx, one.buf ? one.buf : "",
+ git_SHA1_Update(&ctx, one.buf ? one.buf : "",
one.len + 1);
- SHA1_Update(&ctx, two.buf ? two.buf : "",
+ git_SHA1_Update(&ctx, two.buf ? two.buf : "",
two.len + 1);
}
strbuf_reset(&one);
strbuf_reset(&two);
- } else if (hunk == 1)
+ } else if (hunk == RR_SIDE_1)
strbuf_addstr(&one, buf);
- else if (hunk == 2)
+ else if (hunk == RR_ORIGINAL)
+ ; /* discard */
+ else if (hunk == RR_SIDE_2)
strbuf_addstr(&two, buf);
else if (out)
- fputs(buf, out);
+ ferr_puts(buf, out, &wrerror);
continue;
bad:
hunk = 99; /* force error exit */
strbuf_release(&two);
fclose(f);
- if (out)
- fclose(out);
+ if (wrerror)
+ error("There were errors while writing %s (%s)",
+ path, strerror(wrerror));
+ if (out && fclose(out))
+ wrerror = error("Failed to flush %s: %s",
+ path, strerror(errno));
if (sha1)
- SHA1_Final(sha1, &ctx);
- if (hunk) {
+ git_SHA1_Final(sha1, &ctx);
+ if (hunk != RR_CONTEXT) {
if (output)
unlink(output);
return error("Could not parse conflict hunks in %s", path);
}
+ if (wrerror)
+ return -1;
return hunk_no;
}
-static int find_conflict(struct path_list *conflict)
+static int find_conflict(struct string_list *conflict)
{
int i;
if (read_cache() < 0)
ce_same_name(e2, e3) &&
S_ISREG(e2->ce_mode) &&
S_ISREG(e3->ce_mode)) {
- path_list_insert((const char *)e2->name, conflict);
+ string_list_insert((const char *)e2->name, conflict);
i++; /* skip over both #2 and #3 */
}
}
if (!ret) {
FILE *f = fopen(path, "w");
if (!f)
- return error("Could not write to %s", path);
- fwrite(result.ptr, result.size, 1, f);
- fclose(f);
+ return error("Could not open %s: %s", path,
+ strerror(errno));
+ if (fwrite(result.ptr, result.size, 1, f) != 1)
+ error("Could not write %s: %s", path, strerror(errno));
+ if (fclose(f))
+ return error("Writing %s failed: %s", path,
+ strerror(errno));
}
free(cur.ptr);
static struct lock_file index_lock;
-static int update_paths(struct path_list *update)
+static int update_paths(struct string_list *update)
{
int i;
int fd = hold_locked_index(&index_lock, 0);
return -1;
for (i = 0; i < update->nr; i++) {
- struct path_list_item *item = &update->items[i];
- if (add_file_to_cache(item->path, ADD_CACHE_IGNORE_ERRORS))
+ struct string_list_item *item = &update->items[i];
+ if (add_file_to_cache(item->string, ADD_CACHE_IGNORE_ERRORS))
status = -1;
}
return status;
}
-static int do_plain_rerere(struct path_list *rr, int fd)
+static int do_plain_rerere(struct string_list *rr, int fd)
{
- struct path_list conflict = { NULL, 0, 0, 1 };
- struct path_list update = { NULL, 0, 0, 1 };
+ struct string_list conflict = { NULL, 0, 0, 1 };
+ struct string_list update = { NULL, 0, 0, 1 };
int i;
find_conflict(&conflict);
*/
for (i = 0; i < conflict.nr; i++) {
- const char *path = conflict.items[i].path;
- if (!path_list_has_path(rr, path)) {
+ const char *path = conflict.items[i].string;
+ if (!string_list_has_string(rr, path)) {
unsigned char sha1[20];
char *hex;
int ret;
if (ret < 1)
continue;
hex = xstrdup(sha1_to_hex(sha1));
- path_list_insert(path, rr)->util = hex;
+ string_list_insert(path, rr)->util = hex;
if (mkdir(git_path("rr-cache/%s", hex), 0755))
continue;;
handle_file(path, NULL, rr_path(hex, "preimage"));
for (i = 0; i < rr->nr; i++) {
int ret;
- const char *path = rr->items[i].path;
+ const char *path = rr->items[i].string;
const char *name = (const char *)rr->items[i].util;
if (has_resolution(name)) {
if (!merge(name, path)) {
- fprintf(stderr, "Resolved '%s' using "
- "previous resolution.\n", path);
if (rerere_autoupdate)
- path_list_insert(path, &update);
+ string_list_insert(path, &update);
+ fprintf(stderr,
+ "%s '%s' using previous resolution.\n",
+ rerere_autoupdate
+ ? "Staged" : "Resolved",
+ path);
goto mark_resolved;
}
}
static int is_rerere_enabled(void)
{
- struct stat st;
const char *rr_cache;
int rr_cache_exists;
return 0;
rr_cache = git_path("rr-cache");
- rr_cache_exists = !stat(rr_cache, &st) && S_ISDIR(st.st_mode);
+ rr_cache_exists = is_directory(rr_cache);
if (rerere_enabled < 0)
return rr_cache_exists;
return 1;
}
-int setup_rerere(struct path_list *merge_rr)
+int setup_rerere(struct string_list *merge_rr)
{
int fd;
if (!is_rerere_enabled())
return -1;
- merge_rr_path = xstrdup(git_path("MERGE_RR"));
- fd = hold_lock_file_for_update(&write_lock, merge_rr_path, 1);
+ merge_rr_path = git_pathdup("MERGE_RR");
+ fd = hold_lock_file_for_update(&write_lock, merge_rr_path,
+ LOCK_DIE_ON_ERROR);
read_rr(merge_rr);
return fd;
}
int rerere(void)
{
- struct path_list merge_rr = { NULL, 0, 0, 1 };
+ struct string_list merge_rr = { NULL, 0, 0, 1 };
int fd;
fd = setup_rerere(&merge_rr);