{
if (diff_unmodified_pair(p))
return 1;
- if (!S_ISREG(p->one->mode) || !S_ISREG(p->two->mode))
- return 1;
return 0;
}
p->mode = q->queue[i]->two->mode;
memcpy(p->parent[n].sha1, q->queue[i]->one->sha1, 20);
p->parent[n].mode = q->queue[i]->one->mode;
+ p->parent[n].status = q->queue[i]->status;
*tail = p;
tail = &p->next;
}
memcpy(p->parent[n].sha1,
q->queue[i]->one->sha1, 20);
p->parent[n].mode = q->queue[i]->one->mode;
+ p->parent[n].status = q->queue[i]->status;
break;
}
}
unsigned long nmask = (1UL << n);
struct sline *lost_bucket = NULL;
+ if (!cnt)
+ return; /* result deleted */
+
write_temp_blob(parent_tmp, parent);
sprintf(cmd, "diff --unified=0 -La/x -Lb/x '%s' '%s'",
parent_tmp, ourtmp);
int i;
unsigned long lno = 0;
+ if (!cnt)
+ return; /* result deleted */
+
while (1) {
struct sline *sl = &sline[lno];
int hunk_end;
sline->flag |= imask;
sline++;
}
+ /* the overall size of the file (sline[cnt]) */
+ sline->p_lno[i] = sline->p_lno[j];
}
-int show_combined_diff(struct combine_diff_path *elem, int num_parent,
- int dense, const char *header)
+static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
+ int dense, const char *header)
{
unsigned long size, cnt, lno;
char *result, *cp, *ep;
int i, show_hunks, shown_header = 0;
char ourtmp_buf[TMPPATHLEN];
char *ourtmp = ourtmp_buf;
+ int working_tree_file = !memcmp(elem->sha1, null_sha1, 20);
/* Read the result of merge first */
- if (memcmp(elem->sha1, null_sha1, 20)) {
+ if (!working_tree_file) {
result = grab_blob(elem->sha1, &size);
write_to_temp_file(ourtmp, result, size);
}
int len = st.st_size;
int cnt = 0;
+ elem->mode = DIFF_FILE_CANON_MODE(st.st_mode);
size = len;
result = xmalloc(len + 1);
while (cnt < len) {
else {
/* deleted file */
size = 0;
+ elem->mode = 0;
result = xmalloc(1);
result[0] = 0;
ourtmp = "/dev/null";
if (*cp == '\n')
cnt++;
}
- if (result[size-1] != '\n')
+ if (size && result[size-1] != '\n')
cnt++; /* incomplete line */
sline = xcalloc(cnt+1, sizeof(*sline));
ep = result;
sline[0].bol = result;
+ for (lno = 0; lno <= cnt; lno++) {
+ sline[lno].lost_tail = &sline[lno].lost_head;
+ sline[lno].flag = 0;
+ }
for (lno = 0, cp = result; cp - result < size; cp++) {
if (*cp == '\n') {
- sline[lno].lost_tail = &sline[lno].lost_head;
sline[lno].len = cp - sline[lno].bol;
- sline[lno].flag = 0;
lno++;
if (lno < cnt)
sline[lno].bol = cp + 1;
}
}
- if (result[size-1] != '\n') {
- sline[cnt-1].lost_tail = &sline[cnt-1].lost_head;
+ if (size && result[size-1] != '\n')
sline[cnt-1].len = size - (sline[cnt-1].bol - result);
- sline[cnt-1].flag = 0;
- }
sline[0].p_lno = xcalloc((cnt+1) * num_parent, sizeof(unsigned long));
for (lno = 0; lno < cnt; lno++)
show_hunks = make_hunks(sline, cnt, num_parent, dense);
- if (show_hunks || mode_differs) {
+ if (show_hunks || mode_differs || working_tree_file) {
const char *abb;
- char null_abb[DEFAULT_ABBREV + 1];
- memset(null_abb, '0', DEFAULT_ABBREV);
- null_abb[DEFAULT_ABBREV] = 0;
if (header) {
shown_header++;
puts(header);
putchar('\n');
printf("index ");
for (i = 0; i < num_parent; i++) {
- if (elem->parent[i].mode != elem->mode)
- mode_differs = 1;
- if (memcmp(elem->parent[i].sha1, null_sha1, 20))
- abb = find_unique_abbrev(elem->parent[i].sha1,
- DEFAULT_ABBREV);
- else
- abb = null_abb;
+ abb = find_unique_abbrev(elem->parent[i].sha1,
+ DEFAULT_ABBREV);
printf("%s%s", i ? "," : "", abb);
}
- if (memcmp(elem->sha1, null_sha1, 20))
- abb = find_unique_abbrev(elem->sha1, DEFAULT_ABBREV);
- else
- abb = null_abb;
+ abb = find_unique_abbrev(elem->sha1, DEFAULT_ABBREV);
printf("..%s\n", abb);
if (mode_differs) {
- printf("mode ");
- for (i = 0; i < num_parent; i++) {
- printf("%s%06o", i ? "," : "",
- elem->parent[i].mode);
+ int added = !!elem->mode;
+ for (i = 0; added && i < num_parent; i++)
+ if (elem->parent[i].status !=
+ DIFF_STATUS_ADDED)
+ added = 0;
+ if (added)
+ printf("new file mode %06o", elem->mode);
+ else {
+ if (!elem->mode)
+ printf("deleted file ");
+ printf("mode ");
+ for (i = 0; i < num_parent; i++) {
+ printf("%s%06o", i ? "," : "",
+ elem->parent[i].mode);
+ }
+ if (elem->mode)
+ printf("..%06o", elem->mode);
}
- printf("..%06o\n", elem->mode);
+ putchar('\n');
}
- /* if (show_hunks) perhaps */
dump_sline(sline, cnt, num_parent);
}
if (ourtmp == ourtmp_buf)
return shown_header;
}
-int diff_tree_combined_merge(const unsigned char *sha1,
- const char *header, int dense)
+#define COLONS "::::::::::::::::::::::::::::::::"
+
+static void show_raw_diff(struct combine_diff_path *p, int num_parent, const char *header, struct diff_options *opt)
+{
+ int i, offset, mod_type = 'A';
+ const char *prefix;
+ int line_termination, inter_name_termination;
+
+ line_termination = opt->line_termination;
+ inter_name_termination = '\t';
+ if (!line_termination)
+ inter_name_termination = 0;
+
+ if (header)
+ puts(header);
+
+ for (i = 0; i < num_parent; i++) {
+ if (p->parent[i].mode)
+ mod_type = 'M';
+ }
+ if (!p->mode)
+ mod_type = 'D';
+
+ if (opt->output_format == DIFF_FORMAT_RAW) {
+ offset = strlen(COLONS) - num_parent;
+ if (offset < 0)
+ offset = 0;
+ prefix = COLONS + offset;
+
+ /* Show the modes */
+ for (i = 0; i < num_parent; i++) {
+ printf("%s%06o", prefix, p->parent[i].mode);
+ prefix = " ";
+ }
+ printf("%s%06o", prefix, p->mode);
+
+ /* Show sha1's */
+ for (i = 0; i < num_parent; i++)
+ printf(" %s", diff_unique_abbrev(p->parent[i].sha1,
+ opt->abbrev));
+ printf(" %s ", diff_unique_abbrev(p->sha1, opt->abbrev));
+ }
+
+ if (opt->output_format == DIFF_FORMAT_RAW ||
+ opt->output_format == DIFF_FORMAT_NAME_STATUS) {
+ for (i = 0; i < num_parent; i++)
+ putchar(p->parent[i].status);
+ putchar(inter_name_termination);
+ }
+
+ if (line_termination) {
+ if (quote_c_style(p->path, NULL, NULL, 0))
+ quote_c_style(p->path, NULL, stdout, 0);
+ else
+ printf("%s", p->path);
+ putchar(line_termination);
+ }
+ else {
+ printf("%s%c", p->path, line_termination);
+ }
+}
+
+int show_combined_diff(struct combine_diff_path *p,
+ int num_parent,
+ int dense,
+ const char *header,
+ struct diff_options *opt)
+{
+ if (!p->len)
+ return 0;
+ switch (opt->output_format) {
+ case DIFF_FORMAT_RAW:
+ case DIFF_FORMAT_NAME_STATUS:
+ case DIFF_FORMAT_NAME:
+ show_raw_diff(p, num_parent, header, opt);
+ return 1;
+
+ default:
+ case DIFF_FORMAT_PATCH:
+ return show_patch_diff(p, num_parent, dense, header);
+ }
+}
+
+const char *diff_tree_combined_merge(const unsigned char *sha1,
+ const char *header, int dense,
+ struct diff_options *opt)
{
struct commit *commit = lookup_commit(sha1);
struct diff_options diffopts;
struct combine_diff_path *p, *paths = NULL;
int num_parent, i, num_paths;
- diff_setup(&diffopts);
+ diffopts = *opt;
diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
diffopts.recursive = 1;
struct commit *parent = parents->item;
diff_tree_sha1(parent->object.sha1, commit->object.sha1, "",
&diffopts);
+ diffcore_std(&diffopts);
paths = intersect_paths(paths, i, num_parent);
diff_flush(&diffopts);
}
}
if (num_paths) {
for (p = paths; p; p = p->next) {
- if (!p->len)
- continue;
- if (show_combined_diff(p, num_parent, dense, header))
+ if (show_combined_diff(p, num_parent, dense,
+ header, opt))
header = NULL;
}
}
paths = paths->next;
free(tmp);
}
- return 0;
+ return header;
}