mirrors/git
0
0
Fork 0
mirror of https://github.com/git/git.git synced 2024-11-23 18:05:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

[PATCH] Diffcore updates.

Browse Source 
This moves the path selection logic from individual programs to a new
diffcore transformer (diff-tree still needs to have its own for
performance reasons).  Also the header printing code in diff-tree was
tweaked not to produce anything when pickaxe is in effect and there is
nothing interesting to report.  An interesting example is the following
in the GIT archive itself:

    $ git-whatchanged -p -C -S'or something in a real script'

Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Junio C Hamano 2005-05-22 10:04:37 -07:00 committed by Linus Torvalds
parent 26dee0adfc
commit 6b14d7faf0
11 changed files with 266 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Makefile
View File

@ -45,7 +45,7 @@ LIB_H += strbuf.h
LIB_OBJS += strbuf.o
LIB_H += diff.h
LIB_OBJS += diff.o diffcore-rename.o diffcore-pickaxe.o
LIB_OBJS += diff.o diffcore-rename.o diffcore-pickaxe.o diffcore-pathspec.o
LIB_OBJS += gitenv.o
@ -123,9 +123,10 @@ sha1_file.o: $(LIB_H)
usage.o: $(LIB_H)
strbuf.o: $(LIB_H)
gitenv.o: $(LIB_H)
diff.o: $(LIB_H)
diffcore-rename.o : $(LIB_H)
diffcore-pickaxe.o : $(LIB_H)
diff.o: $(LIB_H) diffcore.h
diffcore-rename.o : $(LIB_H) diffcore.h
diffcore-pathspec.o : $(LIB_H) diffcore.h
diffcore-pickaxe.o : $(LIB_H) diffcore.h
test: all
make -C t/ all

27
diff-cache.c
View File

@ -71,7 +71,7 @@ static int show_modified(struct cache_entry *old,
oldmode = old->ce_mode;
if (mode == oldmode && !memcmp(sha1, old->sha1, 20) &&
detect_rename < 2)
detect_rename < DIFF_DETECT_COPY)
return 0;
mode = ntohl(mode);
@ -156,7 +156,7 @@ static void mark_merge_entries(void)
static char *diff_cache_usage =
"git-diff-cache [-p] [-r] [-z] [-m] [-M] [-C] [-R] [-S<string>] [--cached] <tree-ish>";
int main(int argc, char **argv)
int main(int argc, const char **argv)
{
unsigned char tree_sha1[20];
void *tree;
@ -165,7 +165,7 @@ int main(int argc, char **argv)
read_cache();
while (argc > 2) {
char *arg = argv[1];
const char *arg = argv[1];
argv++;
argc--;
if (!strcmp(arg, "-r")) {
@ -177,12 +177,12 @@ int main(int argc, char **argv)
continue;
}
if (!strncmp(arg, "-M", 2)) {
detect_rename = 1;
detect_rename = DIFF_DETECT_RENAME;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
if (!strncmp(arg, "-C", 2)) {
detect_rename = 2;
detect_rename = DIFF_DETECT_COPY;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
@ -209,10 +209,14 @@ int main(int argc, char **argv)
usage(diff_cache_usage);
}
if (argc != 2 || get_sha1(argv[1], tree_sha1))
if (argc < 2 || get_sha1(argv[1], tree_sha1))
usage(diff_cache_usage);
argv++;
argc--;
diff_setup(reverse_diff, diff_output_format);
/* The rest is for paths restriction. */
diff_setup(reverse_diff);
mark_merge_entries();
@ -224,9 +228,12 @@ int main(int argc, char **argv)
ret = diff_cache(active_cache, active_nr);
if (detect_rename)
diff_detect_rename(detect_rename, diff_score_opt);
diffcore_rename(detect_rename, diff_score_opt);
diffcore_prune();
if (pickaxe)
diff_pickaxe(pickaxe);
diff_flush(NULL, 0);
diffcore_pickaxe(pickaxe);
if (2 <= argc)
diffcore_pathspec(argv + 1);
diff_flush(diff_output_format);
return ret;
}

38
diff-files.c
View File

@ -16,21 +16,6 @@ static int diff_score_opt = 0;
static const char *pickaxe = NULL;
static int silent = 0;
static int matches_pathspec(struct cache_entry *ce, char **spec, int cnt)
{
int i;
int namelen = ce_namelen(ce);
for (i = 0; i < cnt; i++) {
int speclen = strlen(spec[i]);
if (! strncmp(spec[i], ce->name, speclen) &&
speclen <= namelen &&
(ce->name[speclen] == 0 ||
ce->name[speclen] == '/'))
return 1;
}
return 0;
}
static void show_unmerge(const char *path)
{
diff_unmerge(path);
@ -48,7 +33,7 @@ static void show_modified(int oldmode, int mode,
diff_change(oldmode, mode, old_sha1, sha1, path, NULL);
}
int main(int argc, char **argv)
int main(int argc, const char **argv)
{
static const unsigned char null_sha1[20] = { 0, };
int entries = read_cache();
@ -71,11 +56,11 @@ int main(int argc, char **argv)
pickaxe = argv[1] + 2;
else if (!strncmp(argv[1], "-M", 2)) {
diff_score_opt = diff_scoreopt_parse(argv[1]);
detect_rename = 1;
detect_rename = DIFF_DETECT_RENAME;
}
else if (!strncmp(argv[1], "-C", 2)) {
diff_score_opt = diff_scoreopt_parse(argv[1]);
detect_rename = 2;
detect_rename = DIFF_DETECT_COPY;
}
else
usage(diff_files_usage);
@ -90,7 +75,7 @@ int main(int argc, char **argv)
exit(1);
}
diff_setup(reverse_diff, diff_output_format);
diff_setup(reverse_diff);
for (i = 0; i < entries; i++) {
struct stat st;
@ -98,10 +83,6 @@ int main(int argc, char **argv)
struct cache_entry *ce = active_cache[i];
int changed;
if (1 < argc &&
! matches_pathspec(ce, argv+1, argc-1))
continue;
if (ce_stage(ce)) {
show_unmerge(ce->name);
while (i < entries &&
@ -122,7 +103,7 @@ int main(int argc, char **argv)
continue;
}
changed = ce_match_stat(ce, &st);
if (!changed && detect_rename < 2)
if (!changed && detect_rename < DIFF_DETECT_COPY)
continue;
oldmode = ntohl(ce->ce_mode);
@ -133,9 +114,12 @@ int main(int argc, char **argv)
ce->name);
}
if (detect_rename)
diff_detect_rename(detect_rename, diff_score_opt);
diffcore_rename(detect_rename, diff_score_opt);
diffcore_prune();
if (pickaxe)
diff_pickaxe(pickaxe);
diff_flush(NULL, 0);
diffcore_pickaxe(pickaxe);
if (1 < argc)
diffcore_pathspec(argv + 1);
diff_flush(diff_output_format);
return 0;
}

17
diff-helper.c
View File

@ -77,11 +77,11 @@ int main(int ac, const char **av) {
else if (av[1][1] == 'P') /* hidden from the help */
diff_output_style = DIFF_FORMAT_MACHINE;
else if (av[1][1] == 'M') {
detect_rename = 1;
detect_rename = DIFF_DETECT_RENAME;
diff_score_opt = diff_scoreopt_parse(av[1]);
}
else if (av[1][1] == 'C') {
detect_rename = 2;
detect_rename = DIFF_DETECT_COPY;
diff_score_opt = diff_scoreopt_parse(av[1]);
}
else if (av[1][1] == 'S') {
@ -93,7 +93,7 @@ int main(int ac, const char **av) {
}
/* the remaining parameters are paths patterns */
diff_setup(reverse_diff, diff_output_style);
diff_setup(reverse_diff);
while (1) {
int status;
read_line(&sb1, stdin, line_termination);
@ -121,14 +121,17 @@ int main(int ac, const char **av) {
status = parse_diff_raw(sb1.buf+1, NULL, NULL);
if (status) {
unrecognized:
diff_flush(av+1, ac-1);
diff_flush(diff_output_style);
printf("%s%c", sb1.buf, line_termination);
}
}
if (detect_rename)
diff_detect_rename(detect_rename, diff_score_opt);
diffcore_rename(detect_rename, diff_score_opt);
diffcore_prune();
if (pickaxe)
diff_pickaxe(pickaxe);
diff_flush(av+1, ac-1);
diffcore_pickaxe(pickaxe);
if (ac)
diffcore_pathspec(av + 1);
diff_flush(diff_output_style);
return 0;
}

44
diff-tree.c
View File

@ -18,7 +18,7 @@ static const char *header_prefix = "";
// What paths are we interested in?
static int nr_paths = 0;
static char **paths = NULL;
static const char **paths = NULL;
static int *pathlens = NULL;
static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base);
@ -67,11 +67,6 @@ static void show_file(const char *prefix, void *tree, unsigned long size, const
const char *path;
const unsigned char *sha1 = extract(tree, size, &path, &mode);
if (header) {
printf("%s", header);
header = NULL;
}
if (silent)
return;
@ -137,10 +132,6 @@ static int compare_tree_entry(void *tree1, unsigned long size1, void *tree2, uns
return retval;
}
if (header) {
printf("%s", header);
header = NULL;
}
if (silent)
return 0;
@ -268,16 +259,29 @@ static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, co
static void call_diff_setup(void)
{
diff_setup(reverse_diff, diff_output_format);
diff_setup(reverse_diff);
}
static void call_diff_flush(void)
static int call_diff_flush()
{
if (detect_rename)
diff_detect_rename(detect_rename, diff_score_opt);
if (pickaxe)
diff_pickaxe(pickaxe);
diff_flush(NULL, 0);
diffcore_rename(detect_rename, diff_score_opt);
diffcore_prune();
if (pickaxe) {
diffcore_pickaxe(pickaxe);
if (diff_queue_is_empty()) {
diff_flush(DIFF_FORMAT_NO_OUTPUT);
return 0;
}
}
if (nr_paths)
diffcore_pathspec(paths);
if (header) {
printf("%s", header);
header = NULL;
}
diff_flush(diff_output_format);
return 1;
}
static int diff_tree_sha1_top(const unsigned char *old,
@ -462,7 +466,7 @@ static int diff_tree_stdin(char *line)
static char *diff_tree_usage =
"git-diff-tree [-p] [-r] [-z] [--stdin] [-M] [-C] [-R] [-S<string>] [-m] [-s] [-v] <tree-ish> <tree-ish>";
int main(int argc, char **argv)
int main(int argc, const char **argv)
{
int nr_sha1;
char line[1000];
@ -470,7 +474,7 @@ int main(int argc, char **argv)
nr_sha1 = 0;
for (;;) {
char *arg;
const char *arg;
argv++;
argc--;
@ -509,12 +513,12 @@ int main(int argc, char **argv)
continue;
}
if (!strncmp(arg, "-M", 2)) {
detect_rename = 1;
detect_rename = DIFF_DETECT_RENAME;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
if (!strncmp(arg, "-C", 2)) {
detect_rename = 2;
detect_rename = DIFF_DETECT_COPY;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}

174
diff.c
View File

@ -16,8 +16,6 @@ static int reverse_diff;
static int generate_patch;
static int line_termination = '\n';
static int inter_name_termination = '\t';
static const char **pathspec;
static int speccnt;
static const char *external_diff(void)
{
@ -286,6 +284,12 @@ int diff_populate_filespec(struct diff_filespec *s)
return 0;
}
void diff_free_filepair(struct diff_filepair *p)
{
free(p->xfrm_msg);
free(p);
}
void diff_free_filespec_data(struct diff_filespec *s)
{
if (s->should_free)
@ -390,25 +394,6 @@ static void remove_tempfile_on_signal(int signo)
remove_tempfile();
}
static int matches_pathspec(const char *name)
{
int i;
int namelen;
if (speccnt == 0)
return 1;
namelen = strlen(name);
for (i = 0; i < speccnt; i++) {
int speclen = strlen(pathspec[i]);
if (! strncmp(pathspec[i], name, speclen) &&
speclen <= namelen &&
(name[speclen] == 0 || name[speclen] == '/'))
return 1;
}
return 0;
}
/* An external diff command takes:
*
* diff-cmd name infile1 infile1-sha1 infile1-mode \
@ -426,9 +411,6 @@ static void run_external_diff(const char *name,
int status;
static int atexit_asked = 0;
if (!matches_pathspec(name) && (!other || !matches_pathspec(other)))
return;
if (one && two) {
prepare_temp_file(name, &temp[0], one);
prepare_temp_file(other ? : name, &temp[1], two);
@ -496,47 +478,26 @@ static void run_external_diff(const char *name,
remove_tempfile();
}
int diff_scoreopt_parse(const char *opt)
{
int diglen, num, scale, i;
if (opt[0] != '-' || (opt[1] != 'M' && opt[1] != 'C'))
return -1; /* that is not a -M nor -C option */
diglen = strspn(opt+2, "0123456789");
if (diglen == 0 || strlen(opt+2) != diglen)
return 0; /* use default */
sscanf(opt+2, "%d", &num);
for (i = 0, scale = 1; i < diglen; i++)
scale *= 10;
/* user says num divided by scale and we say internally that
* is MAX_SCORE * num / scale.
*/
return MAX_SCORE * num / scale;
}
void diff_setup(int reverse_diff_, int diff_output_style)
void diff_setup(int reverse_diff_)
{
reverse_diff = reverse_diff_;
generate_patch = 0;
switch (diff_output_style) {
case DIFF_FORMAT_HUMAN:
line_termination = '\n';
inter_name_termination = '\t';
break;
case DIFF_FORMAT_MACHINE:
line_termination = inter_name_termination = 0;
break;
case DIFF_FORMAT_PATCH:
generate_patch = 1;
break;
}
}
struct diff_queue_struct diff_queued_diff;
void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
{
if (queue->alloc <= queue->nr) {
queue->alloc = alloc_nr(queue->alloc);
queue->queue = xrealloc(queue->queue,
sizeof(dp) * queue->alloc);
}
queue->queue[queue->nr++] = dp;
}
struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
struct diff_filespec *one,
struct diff_filespec *two)
struct diff_filespec *one,
struct diff_filespec *two)
{
struct diff_filepair *dp = xmalloc(sizeof(*dp));
dp->one = one;
@ -544,20 +505,16 @@ struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
dp->xfrm_msg = 0;
dp->orig_order = queue->nr;
dp->xfrm_work = 0;
if (queue->alloc <= queue->nr) {
queue->alloc = alloc_nr(queue->alloc);
queue->queue = xrealloc(queue->queue,
sizeof(dp) * queue->alloc);
}
queue->queue[queue->nr++] = dp;
diff_q(queue, dp);
return dp;
}
static void diff_flush_raw(struct diff_filepair *p)
{
/*
* We used to reject rename/copy but new diff-raw can express them.
*/
if (DIFF_PAIR_UNMERGED(p)) {
printf("U %s%c", p->one->path, line_termination);
return;
}
printf(":%06o %06o %s ",
p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1));
printf("%s%c%s%c%s%c",
@ -576,19 +533,26 @@ 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_external_diff(name, other, p->one, p->two, p->xfrm_msg);
if (DIFF_PAIR_UNMERGED(p))
run_external_diff(name, NULL, NULL, NULL, NULL);
else
run_external_diff(name, other, p->one, p->two, p->xfrm_msg);
}
static int identical(struct diff_filespec *one, struct diff_filespec *two)
static int uninteresting(struct diff_filepair *p)
{
/* This function is written stricter than necessary to support
* the currently implemented transformers, but the idea is to
* let transformers to produce diff_filepairs any way they want,
* and filter and clean them up here before producing the output.
*/
struct diff_filespec *one, *two;
if (!DIFF_FILE_VALID(one) && !DIFF_FILE_VALID(two))
return 1; /* not interesting */
if (DIFF_PAIR_UNMERGED(p))
return 0; /* unmerged is interesting */
one = p->one;
two = p->two;
/* deletion, addition, mode change and renames are all interesting. */
if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) ||
@ -607,9 +571,44 @@ static int identical(struct diff_filespec *one, struct diff_filespec *two)
return 0;
}
void diffcore_prune(void)
{
/*
* Although rename/copy detection wants to have "no-change"
* entries fed into them, the downstream do not need to see
* them. This function removes such entries.
*
* The applications that use rename/copy should:
*
* (1) feed change and "no-change" entries via diff_queue().
* (2) call diffcore_rename, and any other future diffcore_xxx
* that would benefit by still having "no-change" entries.
* (3) call diffcore_prune
* (4) call other diffcore_xxx that do not need to see
* "no-change" entries.
*/
struct diff_queue_struct *q = &diff_queued_diff;
struct diff_queue_struct outq;
int i;
outq.queue = NULL;
outq.nr = outq.alloc = 0;
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
if (!uninteresting(p))
diff_q(&outq, p);
else
diff_free_filepair(p);
}
free(q->queue);
*q = outq;
return;
}
static void diff_flush_one(struct diff_filepair *p)
{
if (identical(p->one, p->two))
if (uninteresting(p))
return;
if (generate_patch)
diff_flush_patch(p);
@ -624,23 +623,32 @@ int diff_queue_is_empty(void)
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
if (!identical(p->one, p->two))
if (!uninteresting(p))
return 0;
}
return 1;
}
void diff_flush(const char **pathspec_, int speccnt_)
void diff_flush(int diff_output_style)
{
struct diff_queue_struct *q = &diff_queued_diff;
int i;
pathspec = pathspec_;
speccnt = speccnt_;
generate_patch = 0;
switch (diff_output_style) {
case DIFF_FORMAT_HUMAN:
line_termination = '\n';
inter_name_termination = '\t';
break;
case DIFF_FORMAT_MACHINE:
line_termination = inter_name_termination = 0;
break;
case DIFF_FORMAT_PATCH:
generate_patch = 1;
break;
}
for (i = 0; i < q->nr; i++)
diff_flush_one(q->queue[i]);
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
diff_free_filespec_data(p->one);
@ -669,7 +677,7 @@ void diff_addremove(int addremove, unsigned mode,
* which but should not make any difference).
* Feeding the same new and old to diff_change() should
* also have the same effect. diff_flush() should
* filter the identical ones out at the final output
* filter uninteresting ones out at the final output
* stage.
*/
if (reverse_diff)
@ -739,8 +747,8 @@ void diff_change(unsigned old_mode, unsigned new_mode,
void diff_unmerge(const char *path)
{
if (generate_patch)
run_external_diff(path, NULL, NULL, NULL, NULL);
else
printf("U %s%c", path, line_termination);
struct diff_filespec *one, *two;
one = alloc_filespec(path);
two = alloc_filespec(path);
diff_queue(&diff_queued_diff, one, two);
}

22
diff.h
View File

@ -26,16 +26,24 @@ extern void diff_unmerge(const char *path);
extern int diff_scoreopt_parse(const char *opt);
#define DIFF_FORMAT_HUMAN 0
#define DIFF_FORMAT_MACHINE 1
#define DIFF_FORMAT_PATCH 2
extern void diff_setup(int reverse, int diff_output_style);
#define DIFF_FORMAT_HUMAN 0
#define DIFF_FORMAT_MACHINE 1
#define DIFF_FORMAT_PATCH 2
#define DIFF_FORMAT_NO_OUTPUT 3
extern void diff_setup(int reverse);
extern void diff_detect_rename(int, int);
extern void diff_pickaxe(const char *);
#define DIFF_DETECT_RENAME 1
#define DIFF_DETECT_COPY 2
extern void diffcore_rename(int rename_copy, int minimum_score);
extern void diffcore_prune(void);
extern void diffcore_pickaxe(const char *needle);
extern void diffcore_pathspec(const char **pathspec);
extern int diff_queue_is_empty(void);
extern void diff_flush(const char **, int);
extern void diff_flush(int output_style);
#endif /* DIFF_H */

63
diffcore-pathspec.c Normal file
View File

@ -0,0 +1,63 @@
/*
* Copyright (C) 2005 Junio C Hamano
*/
#include "cache.h"
#include "diff.h"
#include "diffcore.h"
#include "delta.h"
struct path_spec {
const char *spec;
int len;
};
static int matches_pathspec(const char *name, struct path_spec *s, int cnt)
{
int i;
int namelen;
if (cnt == 0)
return 1;
namelen = strlen(name);
for (i = 0; i < cnt; i++) {
int len = s->len;
if (! strncmp(s->spec, name, len) &&
len <= namelen &&
(name[len] == 0 || name[len] == '/'))
return 1;
}
return 0;
}
void diffcore_pathspec(const char **pathspec)
{
struct diff_queue_struct *q = &diff_queued_diff;
int i, speccnt;
struct diff_queue_struct outq;
struct path_spec *spec;
outq.queue = NULL;
outq.nr = outq.alloc = 0;
for (i = 0; pathspec[i]; i++)
;
speccnt = i;
spec = xmalloc(sizeof(*spec) * speccnt);
for (i = 0; pathspec[i]; i++) {
spec[i].spec = pathspec[i];
spec[i].len = strlen(pathspec[i]);
}
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
if (matches_pathspec(p->one->path, spec, speccnt) ||
matches_pathspec(p->two->path, spec, speccnt))
diff_q(&outq, p);
else
diff_free_filepair(p);
}
free(q->queue);
*q = outq;
return;
}

15
diffcore-pickaxe.c
View File

@ -21,7 +21,7 @@ static int contains(struct diff_filespec *one,
return 0;
}
void diff_pickaxe(const char *needle)
void diffcore_pickaxe(const char *needle)
{
struct diff_queue_struct *q = &diff_queued_diff;
unsigned long len = strlen(needle);
@ -32,24 +32,23 @@ void diff_pickaxe(const char *needle)
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
int onum = outq.nr;
if (!DIFF_FILE_VALID(p->one)) {
if (!DIFF_FILE_VALID(p->two))
continue; /* ignore nonsense */
/* created */
if (contains(p->two, needle, len))
diff_queue(&outq, p->one, p->two);
diff_q(&outq, p);
}
else if (!DIFF_FILE_VALID(p->two)) {
if (contains(p->one, needle, len))
diff_queue(&outq, p->one, p->two);
diff_q(&outq, p);
}
else if (contains(p->one, needle, len) !=
contains(p->two, needle, len))
diff_queue(&outq, p->one, p->two);
}
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
free(p);
diff_q(&outq, p);
if (onum == outq.nr)
diff_free_filepair(p);
}
free(q->queue);
*q = outq;

21
diffcore-rename.c
View File

@ -224,8 +224,25 @@ static int needs_to_stay(struct diff_queue_struct *q, int i,
return 0;
}
void diff_detect_rename(int detect_rename,
int minimum_score)
int diff_scoreopt_parse(const char *opt)
{
int diglen, num, scale, i;
if (opt[0] != '-' || (opt[1] != 'M' && opt[1] != 'C'))
return -1; /* that is not a -M nor -C option */
diglen = strspn(opt+2, "0123456789");
if (diglen == 0 || strlen(opt+2) != diglen)
return 0; /* use default */
sscanf(opt+2, "%d", &num);
for (i = 0, scale = 1; i < diglen; i++)
scale *= 10;
/* user says num divided by scale and we say internally that
* is MAX_SCORE * num / scale.
*/
return MAX_SCORE * num / scale;
}
void diffcore_rename(int detect_rename, int minimum_score)
{
struct diff_queue_struct *q = &diff_queued_diff;
struct diff_queue_struct outq;

4
diffcore.h
View File

@ -45,6 +45,8 @@ struct diff_filepair {
int orig_order; /* the original order of insertion into the queue */
int xfrm_work; /* for use by tramsformers, not by diffcore */
};
#define DIFF_PAIR_UNMERGED(p) \
(!DIFF_FILE_VALID((p)->one) && !DIFF_FILE_VALID((p)->two))
struct diff_queue_struct {
struct diff_filepair **queue;
@ -56,5 +58,7 @@ extern struct diff_queue_struct diff_queued_diff;
extern struct diff_filepair *diff_queue(struct diff_queue_struct *,
struct diff_filespec *,
struct diff_filespec *);
extern void diff_q(struct diff_queue_struct *, struct diff_filepair *);
extern void diff_free_filepair(struct diff_filepair *);
#endif