X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=diff.c;h=c0548eed98df0fb6c11b04a775b6b64b3bb4d417;hb=0cd5da56fa1287a368bb7e0d0e1379591d13f239;hp=3e52fec18792056e230420bdeabff0f9dab5b35a;hpb=e8c80638abc99928dba9ac832589749a531e2e21;p=thirdparty%2Fgit.git diff --git a/diff.c b/diff.c index 3e52fec187..c0548eed98 100644 --- a/diff.c +++ b/diff.c @@ -10,15 +10,66 @@ #include "diffcore.h" static const char *diff_opts = "-pu"; -static unsigned char null_sha1[20] = { 0, }; -static int reverse_diff; static int use_size_cache; +int diff_rename_limit_default = -1; + +int git_diff_config(const char *var, const char *value) +{ + if (!strcmp(var, "diff.renamelimit")) { + diff_rename_limit_default = git_config_int(var, value); + return 0; + } + + return git_default_config(var, value); +} + +static char *quote_one(const char *str) +{ + int needlen; + char *xp; + + if (!str) + return NULL; + needlen = quote_c_style(str, NULL, NULL, 0); + if (!needlen) + return strdup(str); + xp = xmalloc(needlen + 1); + quote_c_style(str, xp, NULL, 0); + return xp; +} + +static char *quote_two(const char *one, const char *two) +{ + int need_one = quote_c_style(one, NULL, NULL, 1); + int need_two = quote_c_style(two, NULL, NULL, 1); + char *xp; + + if (need_one + need_two) { + if (!need_one) need_one = strlen(one); + if (!need_two) need_one = strlen(two); + + xp = xmalloc(need_one + need_two + 3); + xp[0] = '"'; + quote_c_style(one, xp + 1, NULL, 1); + quote_c_style(two, xp + need_one + 1, NULL, 1); + strcpy(xp + need_one + need_two + 1, "\""); + return xp; + } + need_one = strlen(one); + need_two = strlen(two); + xp = xmalloc(need_one + need_two + 1); + strcpy(xp, one); + strcpy(xp + need_one, two); + return xp; +} + static const char *external_diff(void) { static const char *external_diff_cmd = NULL; static int done_preparing = 0; + const char *env_diff_opts; if (done_preparing) return external_diff_cmd; @@ -31,11 +82,11 @@ static const char *external_diff(void) * * GIT_DIFF_OPTS="-c"; */ - if (gitenv("GIT_EXTERNAL_DIFF")) - external_diff_cmd = gitenv("GIT_EXTERNAL_DIFF"); + external_diff_cmd = getenv("GIT_EXTERNAL_DIFF"); /* In case external diff fails... */ - diff_opts = gitenv("GIT_DIFF_OPTS") ? : diff_opts; + env_diff_opts = getenv("GIT_DIFF_OPTS"); + if (env_diff_opts) diff_opts = env_diff_opts; done_preparing = 1; return external_diff_cmd; @@ -127,62 +178,60 @@ static void emit_rewrite_diff(const char *name_a, copy_file('+', temp[1].name); } -static void builtin_diff(const char *name_a, +static const char *builtin_diff(const char *name_a, const char *name_b, struct diff_tempfile *temp, const char *xfrm_msg, - int complete_rewrite) + int complete_rewrite, + const char **args) { int i, next_at, cmd_size; - const char *const diff_cmd = "diff -L%s%s -L%s%s"; - const char *const diff_arg = "%s %s||:"; /* "||:" is to return 0 */ + const char *const diff_cmd = "diff -L%s -L%s"; + const char *const diff_arg = "-- %s %s||:"; /* "||:" is to return 0 */ const char *input_name_sq[2]; - const char *path0[2]; - const char *path1[2]; - const char *name_sq[2]; + const char *label_path[2]; char *cmd; - name_sq[0] = sq_quote(name_a); - name_sq[1] = sq_quote(name_b); - - /* diff_cmd and diff_arg have 6 %s in total which makes - * the sum of these strings 12 bytes larger than required. + /* diff_cmd and diff_arg have 4 %s in total which makes + * the sum of these strings 8 bytes larger than required. * we use 2 spaces around diff-opts, and we need to count - * terminating NUL, so we subtract 9 here. + * terminating NUL; we used to subtract 5 here, but we do not + * care about small leaks in this subprocess that is about + * to exec "diff" anymore. */ - cmd_size = (strlen(diff_cmd) + strlen(diff_opts) + - strlen(diff_arg) - 9); + cmd_size = (strlen(diff_cmd) + strlen(diff_opts) + strlen(diff_arg) + + 128); + for (i = 0; i < 2; i++) { input_name_sq[i] = sq_quote(temp[i].name); - if (!strcmp(temp[i].name, "/dev/null")) { - path0[i] = "/dev/null"; - path1[i] = ""; - } else { - path0[i] = i ? "b/" : "a/"; - path1[i] = name_sq[i]; - } - cmd_size += (strlen(path0[i]) + strlen(path1[i]) + - strlen(input_name_sq[i])); + if (!strcmp(temp[i].name, "/dev/null")) + label_path[i] = "/dev/null"; + else if (!i) + label_path[i] = sq_quote(quote_two("a/", name_a)); + else + label_path[i] = sq_quote(quote_two("b/", name_b)); + cmd_size += (strlen(label_path[i]) + strlen(input_name_sq[i])); } cmd = xmalloc(cmd_size); next_at = 0; next_at += snprintf(cmd+next_at, cmd_size-next_at, - diff_cmd, - path0[0], path1[0], path0[1], path1[1]); + diff_cmd, label_path[0], label_path[1]); next_at += snprintf(cmd+next_at, cmd_size-next_at, " %s ", diff_opts); next_at += snprintf(cmd+next_at, cmd_size-next_at, diff_arg, input_name_sq[0], input_name_sq[1]); - printf("diff --git a/%s b/%s\n", name_a, name_b); - if (!path1[0][0]) { + printf("diff --git %s %s\n", + quote_two("a/", name_a), quote_two("b/", name_b)); + if (label_path[0][0] == '/') { + /* dev/null */ printf("new file mode %s\n", temp[1].mode); if (xfrm_msg && xfrm_msg[0]) puts(xfrm_msg); } - else if (!path1[1][0]) { + else if (label_path[1][0] == '/') { printf("deleted file mode %s\n", temp[0].mode); if (xfrm_msg && xfrm_msg[0]) puts(xfrm_msg); @@ -194,33 +243,34 @@ static void builtin_diff(const char *name_a, } if (xfrm_msg && xfrm_msg[0]) puts(xfrm_msg); + /* + * we do not run diff between different kind + * of objects. + */ if (strncmp(temp[0].mode, temp[1].mode, 3)) - /* we do not run diff between different kind - * of objects. - */ - exit(0); + return NULL; if (complete_rewrite) { - fflush(NULL); emit_rewrite_diff(name_a, name_b, temp); - exit(0); + return NULL; } } - fflush(NULL); - execlp("/bin/sh","sh", "-c", cmd, NULL); + + /* This is disgusting */ + *args++ = "sh"; + *args++ = "-c"; + *args++ = cmd; + *args = NULL; + return "/bin/sh"; } struct diff_filespec *alloc_filespec(const char *path) { int namelen = strlen(path); struct diff_filespec *spec = xmalloc(sizeof(*spec) + namelen + 1); + + memset(spec, 0, sizeof(*spec)); spec->path = (char *)(spec + 1); - strcpy(spec->path, path); - spec->should_free = spec->should_munmap = 0; - spec->xfrm_flags = 0; - spec->size = 0; - spec->data = NULL; - spec->mode = 0; - memset(spec->sha1, 0, 20); + memcpy(spec->path, path, namelen+1); return spec; } @@ -267,7 +317,7 @@ static int work_tree_matches(const char *name, const unsigned char *sha1) ce = active_cache[pos]; if ((lstat(name, &st) < 0) || !S_ISREG(st.st_mode) || /* careful! */ - ce_match_stat(ce, &st) || + ce_match_stat(ce, &st, 0) || memcmp(sha1, ce->sha1, 20)) return 0; /* we return 1 only when we can stat, it is a regular file, @@ -418,7 +468,7 @@ void diff_free_filespec_data(struct diff_filespec *s) static void prep_temp_blob(struct diff_tempfile *temp, void *blob, unsigned long size, - unsigned char *sha1, + const unsigned char *sha1, int mode) { int fd; @@ -460,9 +510,9 @@ static void prepare_temp_file(const char *name, } if (S_ISLNK(st.st_mode)) { int ret; - char *buf, buf_[1024]; - buf = ((sizeof(buf_) < st.st_size) ? - xmalloc(st.st_size) : buf_); + char buf[PATH_MAX + 1]; /* ought to be SYMLINK_MAX */ + if (sizeof(buf) <= st.st_size) + die("symlink too long: %s", name); ret = readlink(name, buf, st.st_size); if (ret < 0) die("readlink(%s)", name); @@ -511,6 +561,42 @@ static void remove_tempfile(void) static void remove_tempfile_on_signal(int signo) { remove_tempfile(); + signal(SIGINT, SIG_DFL); + raise(signo); +} + +static int spawn_prog(const char *pgm, const char **arg) +{ + pid_t pid; + int status; + + fflush(NULL); + pid = fork(); + if (pid < 0) + die("unable to fork"); + if (!pid) { + execvp(pgm, (char *const*) arg); + exit(255); + } + + while (waitpid(pid, &status, 0) < 0) { + if (errno == EINTR) + continue; + return -1; + } + + /* Earlier we did not check the exit status because + * diff exits non-zero if files are different, and + * we are not interested in knowing that. It was a + * mistake which made it harder to quit a diff-* + * session that uses the git-apply-patch-script as + * the GIT_EXTERNAL_DIFF. A custom GIT_EXTERNAL_DIFF + * should also exit non-zero only when it wants to + * abort the entire diff-* session. + */ + if (WIFEXITED(status) && !WEXITSTATUS(status)) + return 0; + return -1; } /* An external diff command takes: @@ -527,14 +613,16 @@ static void run_external_diff(const char *pgm, const char *xfrm_msg, int complete_rewrite) { + const char *spawn_arg[10]; struct diff_tempfile *temp = diff_temp; - pid_t pid; - int status; + int retval; static int atexit_asked = 0; + const char *othername; + othername = (other? other : name); if (one && two) { prepare_temp_file(name, &temp[0], one); - prepare_temp_file(other ? : name, &temp[1], two); + prepare_temp_file(othername, &temp[1], two); if (! atexit_asked && (temp[0].name == temp[0].tmp_path || temp[1].name == temp[1].tmp_path)) { @@ -544,70 +632,69 @@ static void run_external_diff(const char *pgm, signal(SIGINT, remove_tempfile_on_signal); } - fflush(NULL); - pid = fork(); - if (pid < 0) - die("unable to fork"); - if (!pid) { - if (pgm) { - if (one && two) { - const char *exec_arg[10]; - const char **arg = &exec_arg[0]; - *arg++ = pgm; - *arg++ = name; - *arg++ = temp[0].name; - *arg++ = temp[0].hex; - *arg++ = temp[0].mode; - *arg++ = temp[1].name; - *arg++ = temp[1].hex; - *arg++ = temp[1].mode; - if (other) { - *arg++ = other; - *arg++ = xfrm_msg; - } - *arg = NULL; - execvp(pgm, (char *const*) exec_arg); + if (pgm) { + const char **arg = &spawn_arg[0]; + if (one && two) { + *arg++ = pgm; + *arg++ = name; + *arg++ = temp[0].name; + *arg++ = temp[0].hex; + *arg++ = temp[0].mode; + *arg++ = temp[1].name; + *arg++ = temp[1].hex; + *arg++ = temp[1].mode; + if (other) { + *arg++ = other; + *arg++ = xfrm_msg; } - else - execlp(pgm, pgm, name, NULL); + } else { + *arg++ = pgm; + *arg++ = name; } - /* - * otherwise we use the built-in one. - */ - if (one && two) - builtin_diff(name, other ? : name, temp, xfrm_msg, - complete_rewrite); - else + *arg = NULL; + } else { + if (one && two) { + pgm = builtin_diff(name, othername, temp, xfrm_msg, complete_rewrite, spawn_arg); + } else printf("* Unmerged path %s\n", name); - exit(0); } - if (waitpid(pid, &status, 0) < 0 || - !WIFEXITED(status) || WEXITSTATUS(status)) { - /* Earlier we did not check the exit status because - * diff exits non-zero if files are different, and - * we are not interested in knowing that. It was a - * mistake which made it harder to quit a diff-* - * session that uses the git-apply-patch-script as - * the GIT_EXTERNAL_DIFF. A custom GIT_EXTERNAL_DIFF - * should also exit non-zero only when it wants to - * abort the entire diff-* session. - */ - remove_tempfile(); + + retval = 0; + if (pgm) + retval = spawn_prog(pgm, spawn_arg); + remove_tempfile(); + if (retval) { fprintf(stderr, "external diff died, stopping at %s.\n", name); exit(1); } - remove_tempfile(); } -static void run_diff(struct diff_filepair *p) +static void diff_fill_sha1_info(struct diff_filespec *one) +{ + if (DIFF_FILE_VALID(one)) { + if (!one->sha1_valid) { + struct stat st; + if (lstat(one->path, &st) < 0) + die("stat %s", one->path); + if (index_path(one->sha1, one->path, &st, 0)) + die("cannot hash %s\n", one->path); + } + } + else + memset(one->sha1, 0, 20); +} + +static void run_diff(struct diff_filepair *p, struct diff_options *o) { const char *pgm = external_diff(); - char msg_[PATH_MAX*2+200], *xfrm_msg; + char msg[PATH_MAX*2+300], *xfrm_msg; struct diff_filespec *one; struct diff_filespec *two; const char *name; const char *other; + char *name_munged, *other_munged; int complete_rewrite = 0; + int len; if (DIFF_PAIR_UNMERGED(p)) { /* unmerged */ @@ -618,40 +705,65 @@ static void run_diff(struct diff_filepair *p) name = p->one->path; other = (strcmp(name, p->two->path) ? p->two->path : NULL); + name_munged = quote_one(name); + other_munged = quote_one(other); one = p->one; two = p->two; + + diff_fill_sha1_info(one); + diff_fill_sha1_info(two); + + len = 0; switch (p->status) { case DIFF_STATUS_COPIED: - sprintf(msg_, - "similarity index %d%%\n" - "copy from %s\n" - "copy to %s", - (int)(0.5 + p->score * 100.0/MAX_SCORE), - name, other); - xfrm_msg = msg_; + len += snprintf(msg + len, sizeof(msg) - len, + "similarity index %d%%\n" + "copy from %s\n" + "copy to %s\n", + (int)(0.5 + p->score * 100.0/MAX_SCORE), + name_munged, other_munged); break; case DIFF_STATUS_RENAMED: - sprintf(msg_, - "similarity index %d%%\n" - "rename from %s\n" - "rename to %s", - (int)(0.5 + p->score * 100.0/MAX_SCORE), - name, other); - xfrm_msg = msg_; + len += snprintf(msg + len, sizeof(msg) - len, + "similarity index %d%%\n" + "rename from %s\n" + "rename to %s\n", + (int)(0.5 + p->score * 100.0/MAX_SCORE), + name_munged, other_munged); break; case DIFF_STATUS_MODIFIED: if (p->score) { - sprintf(msg_, - "dissimilarity index %d%%", - (int)(0.5 + p->score * 100.0/MAX_SCORE)); - xfrm_msg = msg_; + len += snprintf(msg + len, sizeof(msg) - len, + "dissimilarity index %d%%\n", + (int)(0.5 + p->score * + 100.0/MAX_SCORE)); complete_rewrite = 1; break; } /* fallthru */ default: - xfrm_msg = NULL; + /* nothing */ + ; + } + + if (memcmp(one->sha1, two->sha1, 20)) { + char one_sha1[41]; + int abbrev = o->full_index ? 40 : DEFAULT_ABBREV; + memcpy(one_sha1, sha1_to_hex(one->sha1), 41); + + len += snprintf(msg + len, sizeof(msg) - len, + "index %.*s..%.*s", + abbrev, one_sha1, abbrev, + sha1_to_hex(two->sha1)); + if (one->mode == two->mode) + len += snprintf(msg + len, sizeof(msg) - len, + " %06o", one->mode); + len += snprintf(msg + len, sizeof(msg) - len, "\n"); } + if (len) + msg[--len] = 0; + xfrm_msg = len ? msg : NULL; + if (!pgm && DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) && (S_IFMT & one->mode) != (S_IFMT & two->mode)) { @@ -668,48 +780,143 @@ static void run_diff(struct diff_filepair *p) else run_external_diff(pgm, name, other, one, two, xfrm_msg, complete_rewrite); + + free(name_munged); + free(other_munged); +} + +void diff_setup(struct diff_options *options) +{ + memset(options, 0, sizeof(*options)); + options->output_format = DIFF_FORMAT_RAW; + options->line_termination = '\n'; + options->break_opt = -1; + options->rename_limit = -1; + + options->change = diff_change; + options->add_remove = diff_addremove; } -void diff_setup(int flags) +int diff_setup_done(struct diff_options *options) { - if (flags & DIFF_SETUP_REVERSE) - reverse_diff = 1; - if (flags & DIFF_SETUP_USE_CACHE) { + if ((options->find_copies_harder && + options->detect_rename != DIFF_DETECT_COPY) || + (0 <= options->rename_limit && !options->detect_rename)) + return -1; + if (options->detect_rename && options->rename_limit < 0) + options->rename_limit = diff_rename_limit_default; + if (options->setup & DIFF_SETUP_USE_CACHE) { if (!active_cache) /* read-cache does not die even when it fails * so it is safe for us to do this here. Also * it does not smudge active_cache or active_nr * when it fails, so we do not have to worry about - * cleaning it up oufselves either. + * cleaning it up ourselves either. */ read_cache(); } - if (flags & DIFF_SETUP_USE_SIZE_CACHE) + if (options->setup & DIFF_SETUP_USE_SIZE_CACHE) use_size_cache = 1; - + if (options->abbrev <= 0 || 40 < options->abbrev) + options->abbrev = 40; /* full */ + + return 0; +} + +int diff_opt_parse(struct diff_options *options, const char **av, int ac) +{ + const char *arg = av[0]; + if (!strcmp(arg, "-p") || !strcmp(arg, "-u")) + options->output_format = DIFF_FORMAT_PATCH; + else if (!strcmp(arg, "-z")) + options->line_termination = 0; + else if (!strncmp(arg, "-l", 2)) + options->rename_limit = strtoul(arg+2, NULL, 10); + else if (!strcmp(arg, "--full-index")) + options->full_index = 1; + else if (!strcmp(arg, "--name-only")) + options->output_format = DIFF_FORMAT_NAME; + else if (!strcmp(arg, "--name-status")) + options->output_format = DIFF_FORMAT_NAME_STATUS; + else if (!strcmp(arg, "-R")) + options->reverse_diff = 1; + else if (!strncmp(arg, "-S", 2)) + options->pickaxe = arg + 2; + else if (!strcmp(arg, "-s")) + options->output_format = DIFF_FORMAT_NO_OUTPUT; + else if (!strncmp(arg, "-O", 2)) + options->orderfile = arg + 2; + else if (!strncmp(arg, "--diff-filter=", 14)) + options->filter = arg + 14; + else if (!strcmp(arg, "--pickaxe-all")) + options->pickaxe_opts = DIFF_PICKAXE_ALL; + else if (!strncmp(arg, "-B", 2)) { + if ((options->break_opt = + diff_scoreopt_parse(arg)) == -1) + return -1; + } + else if (!strncmp(arg, "-M", 2)) { + if ((options->rename_score = + diff_scoreopt_parse(arg)) == -1) + return -1; + options->detect_rename = DIFF_DETECT_RENAME; + } + else if (!strncmp(arg, "-C", 2)) { + if ((options->rename_score = + diff_scoreopt_parse(arg)) == -1) + return -1; + options->detect_rename = DIFF_DETECT_COPY; + } + else if (!strcmp(arg, "--find-copies-harder")) + options->find_copies_harder = 1; + else if (!strcmp(arg, "--abbrev")) + options->abbrev = DEFAULT_ABBREV; + else if (!strncmp(arg, "--abbrev=", 9)) { + options->abbrev = strtoul(arg + 9, NULL, 10); + if (options->abbrev < MINIMUM_ABBREV) + options->abbrev = MINIMUM_ABBREV; + else if (40 < options->abbrev) + options->abbrev = 40; + } + else + return 0; + return 1; } static int parse_num(const char **cp_p) { - int num, scale, ch, cnt; + unsigned long num, scale; + int ch, dot; const char *cp = *cp_p; - cnt = num = 0; + num = 0; scale = 1; - while ('0' <= (ch = *cp) && ch <= '9') { - if (cnt++ < 5) { - /* We simply ignore more than 5 digits precision. */ - scale *= 10; - num = num * 10 + ch - '0'; + dot = 0; + for(;;) { + ch = *cp; + if ( !dot && ch == '.' ) { + scale = 1; + dot = 1; + } else if ( ch == '%' ) { + scale = dot ? scale*100 : 100; + cp++; /* % is always at the end */ + break; + } else if ( ch >= '0' && ch <= '9' ) { + if ( scale < 100000 ) { + scale *= 10; + num = (num*10) + (ch-'0'); + } + } else { + break; } - *cp++; + cp++; } *cp_p = cp; /* user says num divided by scale and we say internally that * is MAX_SCORE * num / scale. */ - return (MAX_SCORE * num / scale); + return (num >= scale) ? MAX_SCORE : (MAX_SCORE * num / scale); } int diff_scoreopt_parse(const char *opt) @@ -763,7 +970,8 @@ struct diff_filepair *diff_queue(struct diff_queue_struct *queue, dp->status = 0; dp->source_stays = 0; dp->broken_pair = 0; - diff_q(queue, dp); + if (queue) + diff_q(queue, dp); return dp; } @@ -771,25 +979,52 @@ void diff_free_filepair(struct diff_filepair *p) { diff_free_filespec_data(p->one); diff_free_filespec_data(p->two); + free(p->one); + free(p->two); free(p); } +/* This is different from find_unique_abbrev() in that + * it stuffs the result with dots for alignment. + */ +const char *diff_unique_abbrev(const unsigned char *sha1, int len) +{ + int abblen; + const char *abbrev; + if (len == 40) + return sha1_to_hex(sha1); + + abbrev = find_unique_abbrev(sha1, len); + if (!abbrev) + return sha1_to_hex(sha1); + abblen = strlen(abbrev); + if (abblen < 37) { + static char hex[41]; + if (len < abblen && abblen <= len + 2) + sprintf(hex, "%s%.*s", abbrev, len+3-abblen, ".."); + else + sprintf(hex, "%s...", abbrev); + return hex; + } + return sha1_to_hex(sha1); +} + static void diff_flush_raw(struct diff_filepair *p, int line_termination, - int inter_name_termination) + int inter_name_termination, + struct diff_options *options) { int two_paths; char status[10]; + int abbrev = options->abbrev; + const char *path_one, *path_two; + int output_format = options->output_format; + path_one = p->one->path; + path_two = p->two->path; if (line_termination) { - const char *const err = - "path %s cannot be expressed without -z"; - if (strchr(p->one->path, line_termination) || - strchr(p->one->path, inter_name_termination)) - die(err, p->one->path); - if (strchr(p->two->path, line_termination) || - strchr(p->two->path, inter_name_termination)) - die(err, p->two->path); + path_one = quote_one(path_one); + path_two = quote_one(path_two); } if (p->score) @@ -812,22 +1047,36 @@ static void diff_flush_raw(struct diff_filepair *p, two_paths = 0; break; } - printf(":%06o %06o %s ", - p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1)); - printf("%s %s%c%s", - sha1_to_hex(p->two->sha1), - status, - inter_name_termination, - p->one->path); + if (output_format != DIFF_FORMAT_NAME_STATUS) { + printf(":%06o %06o %s ", + p->one->mode, p->two->mode, + diff_unique_abbrev(p->one->sha1, abbrev)); + printf("%s ", + diff_unique_abbrev(p->two->sha1, abbrev)); + } + printf("%s%c%s", status, inter_name_termination, path_one); if (two_paths) - printf("%c%s", inter_name_termination, p->two->path); + printf("%c%s", inter_name_termination, path_two); putchar(line_termination); + if (path_one != p->one->path) + free((void*)path_one); + if (path_two != p->two->path) + free((void*)path_two); } static void diff_flush_name(struct diff_filepair *p, + int inter_name_termination, int line_termination) { - printf("%s%c", p->two->path, line_termination); + char *path = p->two->path; + + if (line_termination) + path = quote_one(p->two->path); + else + path = p->two->path; + printf("%s%c", path, line_termination); + if (p->two->path != path) + free(path); } int diff_unmodified_pair(struct diff_filepair *p) @@ -864,7 +1113,7 @@ int diff_unmodified_pair(struct diff_filepair *p) return 0; } -static void diff_flush_patch(struct diff_filepair *p) +static void diff_flush_patch(struct diff_filepair *p, struct diff_options *o) { if (diff_unmodified_pair(p)) return; @@ -873,7 +1122,7 @@ static void diff_flush_patch(struct diff_filepair *p) (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode))) return; /* no tree diffs in patch format */ - run_diff(p); + run_diff(p, o); } int diff_queue_is_empty(void) @@ -890,13 +1139,13 @@ int diff_queue_is_empty(void) void diff_debug_filespec(struct diff_filespec *s, int x, const char *one) { fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n", - x, one ? : "", + x, one ? one : "", s->path, DIFF_FILE_VALID(s) ? "valid" : "invalid", s->mode, s->sha1_valid ? sha1_to_hex(s->sha1) : ""); fprintf(stderr, "queue[%d] %s size %lu flags %d\n", - x, one ? : "", + x, one ? one : "", s->size, s->xfrm_flags); } @@ -905,7 +1154,7 @@ void diff_debug_filepair(const struct diff_filepair *p, int i) diff_debug_filespec(p->one, i, "one"); diff_debug_filespec(p->two, i, "two"); fprintf(stderr, "score %d, status %c stays %d broken %d\n", - p->score, p->status ? : '?', + p->score, p->status ? p->status : '?', p->source_stays, p->broken_pair); } @@ -953,7 +1202,9 @@ static void diff_resolve_rename_copy(void) } /* See if there is some other filepair that * copies from the same source as us. If so - * we are a copy. Otherwise we are a rename. + * we are a copy. Otherwise we are either a + * copy if the path stays, or a rename if it + * does not, but we already handled "stays" case. */ for (j = i + 1; j < q->nr; j++) { pp = q->queue[j]; @@ -983,37 +1234,42 @@ static void diff_resolve_rename_copy(void) diff_debug_queue("resolve-rename-copy done", q); } -void diff_flush(int diff_output_style, int line_termination) +void diff_flush(struct diff_options *options) { struct diff_queue_struct *q = &diff_queued_diff; int i; int inter_name_termination = '\t'; + int diff_output_format = options->output_format; + int line_termination = options->line_termination; if (!line_termination) inter_name_termination = 0; for (i = 0; i < q->nr; i++) { struct diff_filepair *p = q->queue[i]; - if ((diff_output_style == DIFF_FORMAT_NO_OUTPUT) || + if ((diff_output_format == DIFF_FORMAT_NO_OUTPUT) || (p->status == DIFF_STATUS_UNKNOWN)) continue; if (p->status == 0) die("internal error in diff-resolve-rename-copy"); - switch (diff_output_style) { + switch (diff_output_format) { case DIFF_FORMAT_PATCH: - diff_flush_patch(p); + diff_flush_patch(p, options); break; case DIFF_FORMAT_RAW: + case DIFF_FORMAT_NAME_STATUS: diff_flush_raw(p, line_termination, - inter_name_termination); + inter_name_termination, + options); break; case DIFF_FORMAT_NAME: - diff_flush_name(p, line_termination); + diff_flush_name(p, + inter_name_termination, + line_termination); break; } - } - for (i = 0; i < q->nr; i++) diff_free_filepair(q->queue[i]); + } free(q->queue); q->queue = NULL; q->nr = q->alloc = 0; @@ -1075,45 +1331,36 @@ static void diffcore_apply_filter(const char *filter) *q = outq; } -void diffcore_std(const char **paths, - int detect_rename, int rename_score, - const char *pickaxe, int pickaxe_opts, - int break_opt, - const char *orderfile, - const char *filter) +void diffcore_std(struct diff_options *options) { - if (paths && paths[0]) - diffcore_pathspec(paths); - if (break_opt != -1) - diffcore_break(break_opt); - if (detect_rename) - diffcore_rename(detect_rename, rename_score); - if (break_opt != -1) + if (options->paths && options->paths[0]) + diffcore_pathspec(options->paths); + if (options->break_opt != -1) + diffcore_break(options->break_opt); + if (options->detect_rename) + diffcore_rename(options); + if (options->break_opt != -1) diffcore_merge_broken(); - if (pickaxe) - diffcore_pickaxe(pickaxe, pickaxe_opts); - if (orderfile) - diffcore_order(orderfile); + if (options->pickaxe) + diffcore_pickaxe(options->pickaxe, options->pickaxe_opts); + if (options->orderfile) + diffcore_order(options->orderfile); diff_resolve_rename_copy(); - diffcore_apply_filter(filter); + diffcore_apply_filter(options->filter); } -void diffcore_std_no_resolve(const char **paths, - const char *pickaxe, int pickaxe_opts, - const char *orderfile, - const char *filter) +void diffcore_std_no_resolve(struct diff_options *options) { - if (paths && paths[0]) - diffcore_pathspec(paths); - if (pickaxe) - diffcore_pickaxe(pickaxe, pickaxe_opts); - if (orderfile) - diffcore_order(orderfile); - diffcore_apply_filter(filter); + if (options->pickaxe) + diffcore_pickaxe(options->pickaxe, options->pickaxe_opts); + if (options->orderfile) + diffcore_order(options->orderfile); + diffcore_apply_filter(options->filter); } -void diff_addremove(int addremove, unsigned mode, +void diff_addremove(struct diff_options *options, + int addremove, unsigned mode, const unsigned char *sha1, const char *base, const char *path) { @@ -1132,7 +1379,7 @@ void diff_addremove(int addremove, unsigned mode, * Before the final output happens, they are pruned after * merged into rename/copy pairs as appropriate. */ - if (reverse_diff) + if (options->reverse_diff) addremove = (addremove == '+' ? '-' : addremove == '-' ? '+' : addremove); @@ -1149,30 +1396,8 @@ void diff_addremove(int addremove, unsigned mode, diff_queue(&diff_queued_diff, one, two); } -void diff_helper_input(unsigned old_mode, - unsigned new_mode, - const unsigned char *old_sha1, - const unsigned char *new_sha1, - const char *old_path, - int status, - int score, - const char *new_path) -{ - struct diff_filespec *one, *two; - struct diff_filepair *dp; - - one = alloc_filespec(old_path); - two = alloc_filespec(new_path); - if (old_mode) - fill_filespec(one, old_sha1, old_mode); - if (new_mode) - fill_filespec(two, new_sha1, new_mode); - dp = diff_queue(&diff_queued_diff, one, two); - dp->score = score * MAX_SCORE / 100; - dp->status = status; -} - -void diff_change(unsigned old_mode, unsigned new_mode, +void diff_change(struct diff_options *options, + unsigned old_mode, unsigned new_mode, const unsigned char *old_sha1, const unsigned char *new_sha1, const char *base, const char *path) @@ -1180,7 +1405,7 @@ void diff_change(unsigned old_mode, unsigned new_mode, char concatpath[PATH_MAX]; struct diff_filespec *one, *two; - if (reverse_diff) { + if (options->reverse_diff) { unsigned tmp; const unsigned char *tmp_c; tmp = old_mode; old_mode = new_mode; new_mode = tmp; @@ -1196,7 +1421,8 @@ void diff_change(unsigned old_mode, unsigned new_mode, diff_queue(&diff_queued_diff, one, two); } -void diff_unmerge(const char *path) +void diff_unmerge(struct diff_options *options, + const char *path) { struct diff_filespec *one, *two; one = alloc_filespec(path);