static int sha1_size_cache_nr, sha1_size_cache_alloc;
static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
+ int find_only,
unsigned long size)
{
int first, last;
first = 0;
last = sha1_size_cache_nr;
while (last > first) {
- int next = (last + first) >> 1;
+ int cmp, next = (last + first) >> 1;
e = sha1_size_cache[next];
- int cmp = memcmp(e->sha1, sha1, 20);
+ cmp = memcmp(e->sha1, sha1, 20);
if (!cmp)
return e;
if (cmp < 0) {
first = next+1;
}
/* not found */
- if (size == UINT_MAX)
+ if (find_only)
return NULL;
/* insert to make it at "first" */
if (sha1_size_cache_alloc <= sha1_size_cache_nr) {
struct sha1_size_cache *e;
if (size_only) {
- e = locate_size_cache(s->sha1, UINT_MAX);
+ e = locate_size_cache(s->sha1, 1, 0);
if (e) {
s->size = e->size;
return 0;
}
if (!sha1_file_size(s->sha1, &s->size))
- locate_size_cache(s->sha1, s->size);
+ locate_size_cache(s->sha1, 0, s->size);
}
else {
s->data = read_sha1_file(s->sha1, type, &s->size);
{
const char *pgm = external_diff();
if (!pgm &&
+ one && two &&
DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
(S_IFMT & one->mode) != (S_IFMT & two->mode)) {
/* a filepair that changes between file and symlink
}
+static int parse_num(const char **cp_p)
+{
+ int num, scale, ch, cnt;
+ const char *cp = *cp_p;
+
+ cnt = 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';
+ }
+ *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);
+}
+
+int diff_scoreopt_parse(const char *opt)
+{
+ int opt1, opt2, cmd;
+
+ if (*opt++ != '-')
+ return -1;
+ cmd = *opt++;
+ if (cmd != 'M' && cmd != 'C' && cmd != 'B')
+ return -1; /* that is not a -M, -C nor -B option */
+
+ opt1 = parse_num(&opt);
+ if (cmd != 'B')
+ opt2 = 0;
+ else {
+ if (*opt == 0)
+ opt2 = 0;
+ else if (*opt != '/')
+ return -1; /* we expect -B80/99 or -B80 */
+ else {
+ opt++;
+ opt2 = parse_num(&opt);
+ }
+ }
+ if (*opt != 0)
+ return -1;
+ return opt1 | (opt2 << 16);
+}
+
struct diff_queue_struct diff_queued_diff;
void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
dp->one = one;
dp->two = two;
dp->score = 0;
+ dp->status = 0;
dp->source_stays = 0;
dp->broken_pair = 0;
diff_q(queue, dp);
case 'R':
sprintf(msg_,
"similarity index %d%%\n"
- "rename old %s\n"
- "rename new %s",
+ "rename from %s\n"
+ "rename to %s",
(int)(0.5 + p->score * 100.0/MAX_SCORE),
p->one->path, p->two->path);
msg = msg_;
diff_debug_queue("resolve-rename-copy done", q);
}
-void diff_flush(int diff_output_style, int resolve_rename_copy)
+void diff_flush(int diff_output_style)
{
struct diff_queue_struct *q = &diff_queued_diff;
int i;
if (diff_output_style == DIFF_FORMAT_MACHINE)
line_termination = inter_name_termination = 0;
- if (resolve_rename_copy)
- diff_resolve_rename_copy();
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
q->nr = q->alloc = 0;
}
+static void diffcore_apply_filter(const char *filter)
+{
+ int i;
+ struct diff_queue_struct *q = &diff_queued_diff;
+ struct diff_queue_struct outq;
+ outq.queue = NULL;
+ outq.nr = outq.alloc = 0;
+
+ if (!filter)
+ return;
+
+ if (strchr(filter, 'A')) {
+ /* All-or-none */
+ int found;
+ for (i = found = 0; !found && i < q->nr; i++) {
+ struct diff_filepair *p = q->queue[i];
+ if ((p->broken_pair && strchr(filter, 'B')) ||
+ (!p->broken_pair && strchr(filter, p->status)))
+ found++;
+ }
+ if (found)
+ return;
+
+ /* otherwise we will clear the whole queue
+ * by copying the empty outq at the end of this
+ * function, but first clear the current entries
+ * in the queue.
+ */
+ for (i = 0; i < q->nr; i++)
+ diff_free_filepair(q->queue[i]);
+ }
+ else {
+ /* Only the matching ones */
+ for (i = 0; i < q->nr; i++) {
+ struct diff_filepair *p = q->queue[i];
+ if ((p->broken_pair && strchr(filter, 'B')) ||
+ (!p->broken_pair && strchr(filter, p->status)))
+ diff_q(&outq, p);
+ else
+ diff_free_filepair(p);
+ }
+ }
+ free(q->queue);
+ *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 *orderfile,
+ const char *filter)
{
if (paths && paths[0])
diffcore_pathspec(paths);
- if (0 <= break_opt)
+ if (break_opt != -1)
diffcore_break(break_opt);
if (detect_rename)
diffcore_rename(detect_rename, rename_score);
+ if (break_opt != -1)
+ diffcore_merge_broken();
+ if (pickaxe)
+ diffcore_pickaxe(pickaxe, pickaxe_opts);
+ if (orderfile)
+ diffcore_order(orderfile);
+ diff_resolve_rename_copy();
+ diffcore_apply_filter(filter);
+}
+
+
+void diffcore_std_no_resolve(const char **paths,
+ const char *pickaxe, int pickaxe_opts,
+ const char *orderfile,
+ const char *filter)
+{
+ if (paths && paths[0])
+ diffcore_pathspec(paths);
if (pickaxe)
diffcore_pickaxe(pickaxe, pickaxe_opts);
if (orderfile)
diffcore_order(orderfile);
+ diffcore_apply_filter(filter);
}
void diff_addremove(int addremove, unsigned mode,