Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2005 Junio C Hamano |
| 3 | */ |
| 4 | #include <sys/types.h> |
| 5 | #include <sys/wait.h> |
Junio C Hamano | 532149d | 2005-04-28 17:13:01 | [diff] [blame] | 6 | #include <signal.h> |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 7 | #include "cache.h" |
Junio C Hamano | 6fb737b | 2005-07-08 06:58:32 | [diff] [blame] | 8 | #include "quote.h" |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 9 | #include "diff.h" |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 10 | #include "diffcore.h" |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 11 | |
Junio C Hamano | d19938a | 2005-05-10 00:57:56 | [diff] [blame] | 12 | static const char *diff_opts = "-pu"; |
Junio C Hamano | 5c97558 | 2005-05-19 10:32:35 | [diff] [blame] | 13 | static unsigned char null_sha1[20] = { 0, }; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 14 | |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 15 | static int reverse_diff; |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 16 | static int use_size_cache; |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 17 | |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 18 | static const char *external_diff(void) |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 19 | { |
Junio C Hamano | d19938a | 2005-05-10 00:57:56 | [diff] [blame] | 20 | static const char *external_diff_cmd = NULL; |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 21 | static int done_preparing = 0; |
Jason Riedy | c7c81b3 | 2005-08-23 20:34:07 | [diff] [blame] | 22 | const char *env_diff_opts; |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 23 | |
| 24 | if (done_preparing) |
| 25 | return external_diff_cmd; |
| 26 | |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 27 | /* |
| 28 | * Default values above are meant to match the |
| 29 | * Linux kernel development style. Examples of |
| 30 | * alternative styles you can specify via environment |
| 31 | * variables are: |
| 32 | * |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 33 | * GIT_DIFF_OPTS="-c"; |
| 34 | */ |
Junio C Hamano | a9ab586 | 2005-09-09 21:48:54 | [diff] [blame] | 35 | external_diff_cmd = getenv("GIT_EXTERNAL_DIFF"); |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 36 | |
| 37 | /* In case external diff fails... */ |
Junio C Hamano | a9ab586 | 2005-09-09 21:48:54 | [diff] [blame] | 38 | env_diff_opts = getenv("GIT_DIFF_OPTS"); |
Jason Riedy | c7c81b3 | 2005-08-23 20:34:07 | [diff] [blame] | 39 | if (env_diff_opts) diff_opts = env_diff_opts; |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 40 | |
| 41 | done_preparing = 1; |
| 42 | return external_diff_cmd; |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 43 | } |
| 44 | |
Holger Eitzenberger | 64f8a63 | 2005-08-04 20:49:49 | [diff] [blame] | 45 | #define TEMPFILE_PATH_LEN 50 |
| 46 | |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 47 | static struct diff_tempfile { |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 48 | const char *name; /* filename external diff should read from */ |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 49 | char hex[41]; |
| 50 | char mode[10]; |
Holger Eitzenberger | 64f8a63 | 2005-08-04 20:49:49 | [diff] [blame] | 51 | char tmp_path[TEMPFILE_PATH_LEN]; |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 52 | } diff_temp[2]; |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 53 | |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 54 | static int count_lines(const char *filename) |
| 55 | { |
| 56 | FILE *in; |
| 57 | int count, ch, completely_empty = 1, nl_just_seen = 0; |
| 58 | in = fopen(filename, "r"); |
| 59 | count = 0; |
| 60 | while ((ch = fgetc(in)) != EOF) |
| 61 | if (ch == '\n') { |
| 62 | count++; |
| 63 | nl_just_seen = 1; |
| 64 | completely_empty = 0; |
| 65 | } |
| 66 | else { |
| 67 | nl_just_seen = 0; |
| 68 | completely_empty = 0; |
| 69 | } |
| 70 | fclose(in); |
| 71 | if (completely_empty) |
| 72 | return 0; |
| 73 | if (!nl_just_seen) |
| 74 | count++; /* no trailing newline */ |
| 75 | return count; |
| 76 | } |
| 77 | |
| 78 | static void print_line_count(int count) |
| 79 | { |
| 80 | switch (count) { |
| 81 | case 0: |
| 82 | printf("0,0"); |
| 83 | break; |
| 84 | case 1: |
| 85 | printf("1"); |
| 86 | break; |
| 87 | default: |
| 88 | printf("1,%d", count); |
| 89 | break; |
| 90 | } |
| 91 | } |
| 92 | |
| 93 | static void copy_file(int prefix, const char *filename) |
| 94 | { |
| 95 | FILE *in; |
| 96 | int ch, nl_just_seen = 1; |
| 97 | in = fopen(filename, "r"); |
| 98 | while ((ch = fgetc(in)) != EOF) { |
| 99 | if (nl_just_seen) |
| 100 | putchar(prefix); |
| 101 | putchar(ch); |
| 102 | if (ch == '\n') |
| 103 | nl_just_seen = 1; |
| 104 | else |
| 105 | nl_just_seen = 0; |
| 106 | } |
| 107 | fclose(in); |
| 108 | if (!nl_just_seen) |
| 109 | printf("\n\\ No newline at end of file\n"); |
| 110 | } |
| 111 | |
| 112 | static void emit_rewrite_diff(const char *name_a, |
| 113 | const char *name_b, |
| 114 | struct diff_tempfile *temp) |
| 115 | { |
| 116 | /* Use temp[i].name as input, name_a and name_b as labels */ |
| 117 | int lc_a, lc_b; |
| 118 | lc_a = count_lines(temp[0].name); |
| 119 | lc_b = count_lines(temp[1].name); |
| 120 | printf("--- %s\n+++ %s\n@@ -", name_a, name_b); |
| 121 | print_line_count(lc_a); |
| 122 | printf(" +"); |
| 123 | print_line_count(lc_b); |
| 124 | printf(" @@\n"); |
| 125 | if (lc_a) |
| 126 | copy_file('-', temp[0].name); |
| 127 | if (lc_b) |
| 128 | copy_file('+', temp[1].name); |
| 129 | } |
| 130 | |
Junio C Hamano | 915838c | 2005-05-18 06:29:49 | [diff] [blame] | 131 | static void builtin_diff(const char *name_a, |
| 132 | const char *name_b, |
Junio C Hamano | 57fe64a | 2005-05-20 02:00:36 | [diff] [blame] | 133 | struct diff_tempfile *temp, |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 134 | const char *xfrm_msg, |
| 135 | int complete_rewrite) |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 136 | { |
Thomas Glanzmann | 9669e17 | 2005-05-19 13:23:18 | [diff] [blame] | 137 | int i, next_at, cmd_size; |
Junio C Hamano | 79db12e | 2005-08-10 04:25:46 | [diff] [blame] | 138 | const char *const diff_cmd = "diff -L%s%s -L%s%s"; |
| 139 | const char *const diff_arg = "%s %s||:"; /* "||:" is to return 0 */ |
Junio C Hamano | 2f97813 | 2005-04-28 15:04:39 | [diff] [blame] | 140 | const char *input_name_sq[2]; |
| 141 | const char *path0[2]; |
| 142 | const char *path1[2]; |
Junio C Hamano | 915838c | 2005-05-18 06:29:49 | [diff] [blame] | 143 | const char *name_sq[2]; |
Junio C Hamano | 2f97813 | 2005-04-28 15:04:39 | [diff] [blame] | 144 | char *cmd; |
Junio C Hamano | 915838c | 2005-05-18 06:29:49 | [diff] [blame] | 145 | |
Junio C Hamano | 6fb737b | 2005-07-08 06:58:32 | [diff] [blame] | 146 | name_sq[0] = sq_quote(name_a); |
| 147 | name_sq[1] = sq_quote(name_b); |
Junio C Hamano | 915838c | 2005-05-18 06:29:49 | [diff] [blame] | 148 | |
Junio C Hamano | c983370 | 2005-05-01 16:33:12 | [diff] [blame] | 149 | /* diff_cmd and diff_arg have 6 %s in total which makes |
| 150 | * the sum of these strings 12 bytes larger than required. |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 151 | * we use 2 spaces around diff-opts, and we need to count |
Junio C Hamano | c983370 | 2005-05-01 16:33:12 | [diff] [blame] | 152 | * terminating NUL, so we subtract 9 here. |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 153 | */ |
Thomas Glanzmann | 9669e17 | 2005-05-19 13:23:18 | [diff] [blame] | 154 | cmd_size = (strlen(diff_cmd) + strlen(diff_opts) + |
Junio C Hamano | c983370 | 2005-05-01 16:33:12 | [diff] [blame] | 155 | strlen(diff_arg) - 9); |
Junio C Hamano | 2f97813 | 2005-04-28 15:04:39 | [diff] [blame] | 156 | for (i = 0; i < 2; i++) { |
Junio C Hamano | 6fb737b | 2005-07-08 06:58:32 | [diff] [blame] | 157 | input_name_sq[i] = sq_quote(temp[i].name); |
Junio C Hamano | 2f97813 | 2005-04-28 15:04:39 | [diff] [blame] | 158 | if (!strcmp(temp[i].name, "/dev/null")) { |
| 159 | path0[i] = "/dev/null"; |
| 160 | path1[i] = ""; |
Junio C Hamano | 2f97813 | 2005-04-28 15:04:39 | [diff] [blame] | 161 | } else { |
Linus Torvalds | 0980d9b | 2005-05-02 04:53:36 | [diff] [blame] | 162 | path0[i] = i ? "b/" : "a/"; |
Junio C Hamano | 915838c | 2005-05-18 06:29:49 | [diff] [blame] | 163 | path1[i] = name_sq[i]; |
Junio C Hamano | 2f97813 | 2005-04-28 15:04:39 | [diff] [blame] | 164 | } |
| 165 | cmd_size += (strlen(path0[i]) + strlen(path1[i]) + |
Junio C Hamano | c983370 | 2005-05-01 16:33:12 | [diff] [blame] | 166 | strlen(input_name_sq[i])); |
Junio C Hamano | 2f97813 | 2005-04-28 15:04:39 | [diff] [blame] | 167 | } |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 168 | |
Junio C Hamano | 2f97813 | 2005-04-28 15:04:39 | [diff] [blame] | 169 | cmd = xmalloc(cmd_size); |
| 170 | |
| 171 | next_at = 0; |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 172 | next_at += snprintf(cmd+next_at, cmd_size-next_at, |
Junio C Hamano | 2f97813 | 2005-04-28 15:04:39 | [diff] [blame] | 173 | diff_cmd, |
Junio C Hamano | c983370 | 2005-05-01 16:33:12 | [diff] [blame] | 174 | path0[0], path1[0], path0[1], path1[1]); |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 175 | next_at += snprintf(cmd+next_at, cmd_size-next_at, |
| 176 | " %s ", diff_opts); |
| 177 | next_at += snprintf(cmd+next_at, cmd_size-next_at, |
Junio C Hamano | 2f97813 | 2005-04-28 15:04:39 | [diff] [blame] | 178 | diff_arg, input_name_sq[0], input_name_sq[1]); |
| 179 | |
Junio C Hamano | 915838c | 2005-05-18 06:29:49 | [diff] [blame] | 180 | printf("diff --git a/%s b/%s\n", name_a, name_b); |
Junio C Hamano | 70aadac | 2005-05-30 23:40:16 | [diff] [blame] | 181 | if (!path1[0][0]) { |
Junio C Hamano | b58f23b | 2005-05-18 16:10:47 | [diff] [blame] | 182 | printf("new file mode %s\n", temp[1].mode); |
Junio C Hamano | 70aadac | 2005-05-30 23:40:16 | [diff] [blame] | 183 | if (xfrm_msg && xfrm_msg[0]) |
| 184 | puts(xfrm_msg); |
| 185 | } |
| 186 | else if (!path1[1][0]) { |
Junio C Hamano | b58f23b | 2005-05-18 16:10:47 | [diff] [blame] | 187 | printf("deleted file mode %s\n", temp[0].mode); |
Junio C Hamano | 70aadac | 2005-05-30 23:40:16 | [diff] [blame] | 188 | if (xfrm_msg && xfrm_msg[0]) |
| 189 | puts(xfrm_msg); |
| 190 | } |
Junio C Hamano | 273b983 | 2005-05-14 01:40:14 | [diff] [blame] | 191 | else { |
Junio C Hamano | b58f23b | 2005-05-18 16:10:47 | [diff] [blame] | 192 | if (strcmp(temp[0].mode, temp[1].mode)) { |
| 193 | printf("old mode %s\n", temp[0].mode); |
| 194 | printf("new mode %s\n", temp[1].mode); |
| 195 | } |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 196 | if (xfrm_msg && xfrm_msg[0]) |
Junio C Hamano | 09d9d1a | 2005-05-27 22:54:06 | [diff] [blame] | 197 | puts(xfrm_msg); |
Junio C Hamano | 273b983 | 2005-05-14 01:40:14 | [diff] [blame] | 198 | if (strncmp(temp[0].mode, temp[1].mode, 3)) |
| 199 | /* we do not run diff between different kind |
| 200 | * of objects. |
| 201 | */ |
Junio C Hamano | b28858b | 2005-05-05 23:10:21 | [diff] [blame] | 202 | exit(0); |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 203 | if (complete_rewrite) { |
| 204 | fflush(NULL); |
| 205 | emit_rewrite_diff(name_a, name_b, temp); |
| 206 | exit(0); |
| 207 | } |
Junio C Hamano | b28858b | 2005-05-05 23:10:21 | [diff] [blame] | 208 | } |
Junio C Hamano | c983370 | 2005-05-01 16:33:12 | [diff] [blame] | 209 | fflush(NULL); |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 210 | execlp("/bin/sh","sh", "-c", cmd, NULL); |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 211 | } |
| 212 | |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 213 | struct diff_filespec *alloc_filespec(const char *path) |
| 214 | { |
| 215 | int namelen = strlen(path); |
| 216 | struct diff_filespec *spec = xmalloc(sizeof(*spec) + namelen + 1); |
Linus Torvalds | 705a714 | 2005-09-14 20:41:24 | [diff] [blame] | 217 | |
| 218 | memset(spec, 0, sizeof(*spec)); |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 219 | spec->path = (char *)(spec + 1); |
Linus Torvalds | 705a714 | 2005-09-14 20:41:24 | [diff] [blame] | 220 | memcpy(spec->path, path, namelen+1); |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 221 | return spec; |
| 222 | } |
| 223 | |
| 224 | void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1, |
| 225 | unsigned short mode) |
| 226 | { |
Junio C Hamano | 4130b99 | 2005-05-26 09:24:30 | [diff] [blame] | 227 | if (mode) { |
| 228 | spec->mode = DIFF_FILE_CANON_MODE(mode); |
Junio C Hamano | 81e50ea | 2005-05-22 02:42:18 | [diff] [blame] | 229 | memcpy(spec->sha1, sha1, 20); |
| 230 | spec->sha1_valid = !!memcmp(sha1, null_sha1, 20); |
| 231 | } |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 232 | } |
| 233 | |
Junio C Hamano | b46f0b6 | 2005-05-04 08:45:24 | [diff] [blame] | 234 | /* |
| 235 | * Given a name and sha1 pair, if the dircache tells us the file in |
| 236 | * the work tree has that object contents, return true, so that |
| 237 | * prepare_temp_file() does not have to inflate and extract. |
| 238 | */ |
| 239 | static int work_tree_matches(const char *name, const unsigned char *sha1) |
| 240 | { |
| 241 | struct cache_entry *ce; |
| 242 | struct stat st; |
| 243 | int pos, len; |
Junio C Hamano | 5c97558 | 2005-05-19 10:32:35 | [diff] [blame] | 244 | |
Junio C Hamano | b46f0b6 | 2005-05-04 08:45:24 | [diff] [blame] | 245 | /* We do not read the cache ourselves here, because the |
| 246 | * benchmark with my previous version that always reads cache |
| 247 | * shows that it makes things worse for diff-tree comparing |
| 248 | * two linux-2.6 kernel trees in an already checked out work |
Junio C Hamano | 915838c | 2005-05-18 06:29:49 | [diff] [blame] | 249 | * tree. This is because most diff-tree comparisons deal with |
Junio C Hamano | b46f0b6 | 2005-05-04 08:45:24 | [diff] [blame] | 250 | * only a small number of files, while reading the cache is |
| 251 | * expensive for a large project, and its cost outweighs the |
| 252 | * savings we get by not inflating the object to a temporary |
| 253 | * file. Practically, this code only helps when we are used |
| 254 | * by diff-cache --cached, which does read the cache before |
| 255 | * calling us. |
Junio C Hamano | 57fe64a | 2005-05-20 02:00:36 | [diff] [blame] | 256 | */ |
Junio C Hamano | b46f0b6 | 2005-05-04 08:45:24 | [diff] [blame] | 257 | if (!active_cache) |
| 258 | return 0; |
| 259 | |
| 260 | len = strlen(name); |
| 261 | pos = cache_name_pos(name, len); |
| 262 | if (pos < 0) |
| 263 | return 0; |
| 264 | ce = active_cache[pos]; |
Junio C Hamano | b28858b | 2005-05-05 23:10:21 | [diff] [blame] | 265 | if ((lstat(name, &st) < 0) || |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 266 | !S_ISREG(st.st_mode) || /* careful! */ |
Brad Roberts | 5d728c8 | 2005-05-15 02:04:25 | [diff] [blame] | 267 | ce_match_stat(ce, &st) || |
Junio C Hamano | b46f0b6 | 2005-05-04 08:45:24 | [diff] [blame] | 268 | memcmp(sha1, ce->sha1, 20)) |
| 269 | return 0; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 270 | /* we return 1 only when we can stat, it is a regular file, |
| 271 | * stat information matches, and sha1 recorded in the cache |
| 272 | * matches. I.e. we know the file in the work tree really is |
| 273 | * the same as the <name, sha1> pair. |
| 274 | */ |
Junio C Hamano | b46f0b6 | 2005-05-04 08:45:24 | [diff] [blame] | 275 | return 1; |
| 276 | } |
| 277 | |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 278 | static struct sha1_size_cache { |
| 279 | unsigned char sha1[20]; |
| 280 | unsigned long size; |
| 281 | } **sha1_size_cache; |
| 282 | static int sha1_size_cache_nr, sha1_size_cache_alloc; |
| 283 | |
| 284 | static struct sha1_size_cache *locate_size_cache(unsigned char *sha1, |
Junio C Hamano | 0601e13 | 2005-06-04 06:02:23 | [diff] [blame] | 285 | int find_only, |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 286 | unsigned long size) |
| 287 | { |
| 288 | int first, last; |
| 289 | struct sha1_size_cache *e; |
| 290 | |
| 291 | first = 0; |
| 292 | last = sha1_size_cache_nr; |
| 293 | while (last > first) { |
Junio C Hamano | 0601e13 | 2005-06-04 06:02:23 | [diff] [blame] | 294 | int cmp, next = (last + first) >> 1; |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 295 | e = sha1_size_cache[next]; |
Junio C Hamano | 0601e13 | 2005-06-04 06:02:23 | [diff] [blame] | 296 | cmp = memcmp(e->sha1, sha1, 20); |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 297 | if (!cmp) |
| 298 | return e; |
| 299 | if (cmp < 0) { |
| 300 | last = next; |
| 301 | continue; |
| 302 | } |
| 303 | first = next+1; |
| 304 | } |
| 305 | /* not found */ |
Junio C Hamano | 0601e13 | 2005-06-04 06:02:23 | [diff] [blame] | 306 | if (find_only) |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 307 | return NULL; |
| 308 | /* insert to make it at "first" */ |
| 309 | if (sha1_size_cache_alloc <= sha1_size_cache_nr) { |
| 310 | sha1_size_cache_alloc = alloc_nr(sha1_size_cache_alloc); |
| 311 | sha1_size_cache = xrealloc(sha1_size_cache, |
| 312 | sha1_size_cache_alloc * |
| 313 | sizeof(*sha1_size_cache)); |
| 314 | } |
| 315 | sha1_size_cache_nr++; |
| 316 | if (first < sha1_size_cache_nr) |
| 317 | memmove(sha1_size_cache + first + 1, sha1_size_cache + first, |
| 318 | (sha1_size_cache_nr - first - 1) * |
| 319 | sizeof(*sha1_size_cache)); |
| 320 | e = xmalloc(sizeof(struct sha1_size_cache)); |
| 321 | sha1_size_cache[first] = e; |
| 322 | memcpy(e->sha1, sha1, 20); |
| 323 | e->size = size; |
| 324 | return e; |
| 325 | } |
| 326 | |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 327 | /* |
| 328 | * While doing rename detection and pickaxe operation, we may need to |
| 329 | * grab the data for the blob (or file) for our own in-core comparison. |
| 330 | * diff_filespec has data and size fields for this purpose. |
| 331 | */ |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 332 | int diff_populate_filespec(struct diff_filespec *s, int size_only) |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 333 | { |
| 334 | int err = 0; |
Junio C Hamano | 81e50ea | 2005-05-22 02:42:18 | [diff] [blame] | 335 | if (!DIFF_FILE_VALID(s)) |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 336 | die("internal error: asking to populate invalid file."); |
| 337 | if (S_ISDIR(s->mode)) |
| 338 | return -1; |
| 339 | |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 340 | if (!use_size_cache) |
| 341 | size_only = 0; |
| 342 | |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 343 | if (s->data) |
| 344 | return err; |
| 345 | if (!s->sha1_valid || |
| 346 | work_tree_matches(s->path, s->sha1)) { |
| 347 | struct stat st; |
| 348 | int fd; |
| 349 | if (lstat(s->path, &st) < 0) { |
| 350 | if (errno == ENOENT) { |
| 351 | err_empty: |
| 352 | err = -1; |
| 353 | empty: |
| 354 | s->data = ""; |
| 355 | s->size = 0; |
| 356 | return err; |
| 357 | } |
| 358 | } |
| 359 | s->size = st.st_size; |
| 360 | if (!s->size) |
| 361 | goto empty; |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 362 | if (size_only) |
| 363 | return 0; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 364 | if (S_ISLNK(st.st_mode)) { |
| 365 | int ret; |
| 366 | s->data = xmalloc(s->size); |
| 367 | s->should_free = 1; |
| 368 | ret = readlink(s->path, s->data, s->size); |
| 369 | if (ret < 0) { |
| 370 | free(s->data); |
| 371 | goto err_empty; |
| 372 | } |
| 373 | return 0; |
| 374 | } |
| 375 | fd = open(s->path, O_RDONLY); |
| 376 | if (fd < 0) |
| 377 | goto err_empty; |
| 378 | s->data = mmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0); |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 379 | close(fd); |
Pavel Roskin | e35f982 | 2005-07-29 14:49:14 | [diff] [blame] | 380 | if (s->data == MAP_FAILED) |
| 381 | goto err_empty; |
| 382 | s->should_munmap = 1; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 383 | } |
| 384 | else { |
| 385 | char type[20]; |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 386 | struct sha1_size_cache *e; |
| 387 | |
| 388 | if (size_only) { |
Junio C Hamano | 0601e13 | 2005-06-04 06:02:23 | [diff] [blame] | 389 | e = locate_size_cache(s->sha1, 1, 0); |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 390 | if (e) { |
| 391 | s->size = e->size; |
| 392 | return 0; |
| 393 | } |
Junio C Hamano | 36e4d74 | 2005-06-27 10:34:06 | [diff] [blame] | 394 | if (!sha1_object_info(s->sha1, type, &s->size)) |
Junio C Hamano | 0601e13 | 2005-06-04 06:02:23 | [diff] [blame] | 395 | locate_size_cache(s->sha1, 0, s->size); |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 396 | } |
Junio C Hamano | 65c2e0c | 2005-06-02 22:20:54 | [diff] [blame] | 397 | else { |
| 398 | s->data = read_sha1_file(s->sha1, type, &s->size); |
| 399 | s->should_free = 1; |
| 400 | } |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 401 | } |
| 402 | return 0; |
| 403 | } |
| 404 | |
Junio C Hamano | 19397b4 | 2005-09-14 21:06:50 | [diff] [blame] | 405 | void diff_free_filespec_data(struct diff_filespec *s) |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 406 | { |
| 407 | if (s->should_free) |
| 408 | free(s->data); |
| 409 | else if (s->should_munmap) |
| 410 | munmap(s->data, s->size); |
Junio C Hamano | 19397b4 | 2005-09-14 21:06:50 | [diff] [blame] | 411 | s->should_free = s->should_munmap = 0; |
| 412 | s->data = NULL; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 413 | } |
| 414 | |
Junio C Hamano | b28858b | 2005-05-05 23:10:21 | [diff] [blame] | 415 | static void prep_temp_blob(struct diff_tempfile *temp, |
| 416 | void *blob, |
| 417 | unsigned long size, |
| 418 | unsigned char *sha1, |
| 419 | int mode) |
| 420 | { |
| 421 | int fd; |
| 422 | |
Holger Eitzenberger | 64f8a63 | 2005-08-04 20:49:49 | [diff] [blame] | 423 | fd = git_mkstemp(temp->tmp_path, TEMPFILE_PATH_LEN, ".diff_XXXXXX"); |
Junio C Hamano | b28858b | 2005-05-05 23:10:21 | [diff] [blame] | 424 | if (fd < 0) |
| 425 | die("unable to create temp-file"); |
| 426 | if (write(fd, blob, size) != size) |
| 427 | die("unable to write temp-file"); |
| 428 | close(fd); |
| 429 | temp->name = temp->tmp_path; |
| 430 | strcpy(temp->hex, sha1_to_hex(sha1)); |
| 431 | temp->hex[40] = 0; |
| 432 | sprintf(temp->mode, "%06o", mode); |
| 433 | } |
| 434 | |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 435 | static void prepare_temp_file(const char *name, |
| 436 | struct diff_tempfile *temp, |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 437 | struct diff_filespec *one) |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 438 | { |
Junio C Hamano | 81e50ea | 2005-05-22 02:42:18 | [diff] [blame] | 439 | if (!DIFF_FILE_VALID(one)) { |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 440 | not_a_valid_file: |
Junio C Hamano | 532149d | 2005-04-28 17:13:01 | [diff] [blame] | 441 | /* A '-' entry produces this for file-2, and |
| 442 | * a '+' entry produces this for file-1. |
| 443 | */ |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 444 | temp->name = "/dev/null"; |
| 445 | strcpy(temp->hex, "."); |
| 446 | strcpy(temp->mode, "."); |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 447 | return; |
| 448 | } |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 449 | |
Junio C Hamano | 5c97558 | 2005-05-19 10:32:35 | [diff] [blame] | 450 | if (!one->sha1_valid || |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 451 | work_tree_matches(name, one->sha1)) { |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 452 | struct stat st; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 453 | if (lstat(name, &st) < 0) { |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 454 | if (errno == ENOENT) |
| 455 | goto not_a_valid_file; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 456 | die("stat(%s): %s", name, strerror(errno)); |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 457 | } |
Junio C Hamano | b28858b | 2005-05-05 23:10:21 | [diff] [blame] | 458 | if (S_ISLNK(st.st_mode)) { |
| 459 | int ret; |
| 460 | char *buf, buf_[1024]; |
| 461 | buf = ((sizeof(buf_) < st.st_size) ? |
| 462 | xmalloc(st.st_size) : buf_); |
| 463 | ret = readlink(name, buf, st.st_size); |
| 464 | if (ret < 0) |
| 465 | die("readlink(%s)", name); |
| 466 | prep_temp_blob(temp, buf, st.st_size, |
| 467 | (one->sha1_valid ? |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 468 | one->sha1 : null_sha1), |
Junio C Hamano | b28858b | 2005-05-05 23:10:21 | [diff] [blame] | 469 | (one->sha1_valid ? |
| 470 | one->mode : S_IFLNK)); |
| 471 | } |
| 472 | else { |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 473 | /* we can borrow from the file in the work tree */ |
| 474 | temp->name = name; |
Junio C Hamano | b28858b | 2005-05-05 23:10:21 | [diff] [blame] | 475 | if (!one->sha1_valid) |
| 476 | strcpy(temp->hex, sha1_to_hex(null_sha1)); |
| 477 | else |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 478 | strcpy(temp->hex, sha1_to_hex(one->sha1)); |
Junio C Hamano | 9d429ff | 2005-05-30 07:07:39 | [diff] [blame] | 479 | /* Even though we may sometimes borrow the |
| 480 | * contents from the work tree, we always want |
| 481 | * one->mode. mode is trustworthy even when |
| 482 | * !(one->sha1_valid), as long as |
| 483 | * DIFF_FILE_VALID(one). |
| 484 | */ |
| 485 | sprintf(temp->mode, "%06o", one->mode); |
Junio C Hamano | b28858b | 2005-05-05 23:10:21 | [diff] [blame] | 486 | } |
| 487 | return; |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 488 | } |
| 489 | else { |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 490 | if (diff_populate_filespec(one, 0)) |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 491 | die("cannot read data blob for %s", one->path); |
| 492 | prep_temp_blob(temp, one->data, one->size, |
| 493 | one->sha1, one->mode); |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 494 | } |
| 495 | } |
| 496 | |
| 497 | static void remove_tempfile(void) |
| 498 | { |
| 499 | int i; |
| 500 | |
| 501 | for (i = 0; i < 2; i++) |
| 502 | if (diff_temp[i].name == diff_temp[i].tmp_path) { |
| 503 | unlink(diff_temp[i].name); |
| 504 | diff_temp[i].name = NULL; |
| 505 | } |
| 506 | } |
| 507 | |
Junio C Hamano | 532149d | 2005-04-28 17:13:01 | [diff] [blame] | 508 | static void remove_tempfile_on_signal(int signo) |
| 509 | { |
| 510 | remove_tempfile(); |
| 511 | } |
| 512 | |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 513 | /* An external diff command takes: |
| 514 | * |
| 515 | * diff-cmd name infile1 infile1-sha1 infile1-mode \ |
Junio C Hamano | 5c97558 | 2005-05-19 10:32:35 | [diff] [blame] | 516 | * infile2 infile2-sha1 infile2-mode [ rename-to ] |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 517 | * |
| 518 | */ |
Junio C Hamano | 4130b99 | 2005-05-26 09:24:30 | [diff] [blame] | 519 | static void run_external_diff(const char *pgm, |
| 520 | const char *name, |
Junio C Hamano | 5c97558 | 2005-05-19 10:32:35 | [diff] [blame] | 521 | const char *other, |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 522 | struct diff_filespec *one, |
| 523 | struct diff_filespec *two, |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 524 | const char *xfrm_msg, |
| 525 | int complete_rewrite) |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 526 | { |
| 527 | struct diff_tempfile *temp = diff_temp; |
Junio C Hamano | 532149d | 2005-04-28 17:13:01 | [diff] [blame] | 528 | pid_t pid; |
| 529 | int status; |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 530 | static int atexit_asked = 0; |
Jason Riedy | c7c81b3 | 2005-08-23 20:34:07 | [diff] [blame] | 531 | const char *othername; |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 532 | |
Jason Riedy | c7c81b3 | 2005-08-23 20:34:07 | [diff] [blame] | 533 | othername = (other? other : name); |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 534 | if (one && two) { |
| 535 | prepare_temp_file(name, &temp[0], one); |
Jason Riedy | c7c81b3 | 2005-08-23 20:34:07 | [diff] [blame] | 536 | prepare_temp_file(othername, &temp[1], two); |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 537 | if (! atexit_asked && |
| 538 | (temp[0].name == temp[0].tmp_path || |
| 539 | temp[1].name == temp[1].tmp_path)) { |
| 540 | atexit_asked = 1; |
| 541 | atexit(remove_tempfile); |
| 542 | } |
Junio C Hamano | 532149d | 2005-04-28 17:13:01 | [diff] [blame] | 543 | signal(SIGINT, remove_tempfile_on_signal); |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 544 | } |
| 545 | |
| 546 | fflush(NULL); |
| 547 | pid = fork(); |
| 548 | if (pid < 0) |
| 549 | die("unable to fork"); |
| 550 | if (!pid) { |
Junio C Hamano | 5c97558 | 2005-05-19 10:32:35 | [diff] [blame] | 551 | if (pgm) { |
| 552 | if (one && two) { |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 553 | const char *exec_arg[10]; |
Junio C Hamano | 5c97558 | 2005-05-19 10:32:35 | [diff] [blame] | 554 | const char **arg = &exec_arg[0]; |
| 555 | *arg++ = pgm; |
| 556 | *arg++ = name; |
| 557 | *arg++ = temp[0].name; |
| 558 | *arg++ = temp[0].hex; |
| 559 | *arg++ = temp[0].mode; |
| 560 | *arg++ = temp[1].name; |
| 561 | *arg++ = temp[1].hex; |
| 562 | *arg++ = temp[1].mode; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 563 | if (other) { |
Junio C Hamano | 5c97558 | 2005-05-19 10:32:35 | [diff] [blame] | 564 | *arg++ = other; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 565 | *arg++ = xfrm_msg; |
| 566 | } |
Linus Torvalds | 09d74b3 | 2005-05-22 21:33:43 | [diff] [blame] | 567 | *arg = NULL; |
Junio C Hamano | 5c97558 | 2005-05-19 10:32:35 | [diff] [blame] | 568 | execvp(pgm, (char *const*) exec_arg); |
| 569 | } |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 570 | else |
| 571 | execlp(pgm, pgm, name, NULL); |
| 572 | } |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 573 | /* |
| 574 | * otherwise we use the built-in one. |
| 575 | */ |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 576 | if (one && two) |
Jason Riedy | c7c81b3 | 2005-08-23 20:34:07 | [diff] [blame] | 577 | builtin_diff(name, othername, temp, xfrm_msg, |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 578 | complete_rewrite); |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 579 | else |
| 580 | printf("* Unmerged path %s\n", name); |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 581 | exit(0); |
| 582 | } |
Junio C Hamano | 6fa2806 | 2005-05-04 08:38:06 | [diff] [blame] | 583 | if (waitpid(pid, &status, 0) < 0 || |
| 584 | !WIFEXITED(status) || WEXITSTATUS(status)) { |
| 585 | /* Earlier we did not check the exit status because |
Junio C Hamano | 532149d | 2005-04-28 17:13:01 | [diff] [blame] | 586 | * diff exits non-zero if files are different, and |
Junio C Hamano | 6fa2806 | 2005-05-04 08:38:06 | [diff] [blame] | 587 | * we are not interested in knowing that. It was a |
| 588 | * mistake which made it harder to quit a diff-* |
| 589 | * session that uses the git-apply-patch-script as |
| 590 | * the GIT_EXTERNAL_DIFF. A custom GIT_EXTERNAL_DIFF |
| 591 | * should also exit non-zero only when it wants to |
| 592 | * abort the entire diff-* session. |
Junio C Hamano | 532149d | 2005-04-28 17:13:01 | [diff] [blame] | 593 | */ |
| 594 | remove_tempfile(); |
Junio C Hamano | 6fa2806 | 2005-05-04 08:38:06 | [diff] [blame] | 595 | fprintf(stderr, "external diff died, stopping at %s.\n", name); |
| 596 | exit(1); |
Junio C Hamano | 532149d | 2005-04-28 17:13:01 | [diff] [blame] | 597 | } |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 598 | remove_tempfile(); |
| 599 | } |
| 600 | |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 601 | static void run_diff(struct diff_filepair *p) |
Junio C Hamano | 4130b99 | 2005-05-26 09:24:30 | [diff] [blame] | 602 | { |
| 603 | const char *pgm = external_diff(); |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 604 | char msg_[PATH_MAX*2+200], *xfrm_msg; |
| 605 | struct diff_filespec *one; |
| 606 | struct diff_filespec *two; |
| 607 | const char *name; |
| 608 | const char *other; |
| 609 | int complete_rewrite = 0; |
| 610 | |
| 611 | if (DIFF_PAIR_UNMERGED(p)) { |
| 612 | /* unmerged */ |
| 613 | run_external_diff(pgm, p->one->path, NULL, NULL, NULL, NULL, |
| 614 | 0); |
| 615 | return; |
| 616 | } |
| 617 | |
| 618 | name = p->one->path; |
| 619 | other = (strcmp(name, p->two->path) ? p->two->path : NULL); |
| 620 | one = p->one; two = p->two; |
| 621 | switch (p->status) { |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 622 | case DIFF_STATUS_COPIED: |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 623 | sprintf(msg_, |
| 624 | "similarity index %d%%\n" |
| 625 | "copy from %s\n" |
| 626 | "copy to %s", |
| 627 | (int)(0.5 + p->score * 100.0/MAX_SCORE), |
| 628 | name, other); |
| 629 | xfrm_msg = msg_; |
| 630 | break; |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 631 | case DIFF_STATUS_RENAMED: |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 632 | sprintf(msg_, |
| 633 | "similarity index %d%%\n" |
| 634 | "rename from %s\n" |
| 635 | "rename to %s", |
| 636 | (int)(0.5 + p->score * 100.0/MAX_SCORE), |
| 637 | name, other); |
| 638 | xfrm_msg = msg_; |
| 639 | break; |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 640 | case DIFF_STATUS_MODIFIED: |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 641 | if (p->score) { |
| 642 | sprintf(msg_, |
| 643 | "dissimilarity index %d%%", |
| 644 | (int)(0.5 + p->score * 100.0/MAX_SCORE)); |
| 645 | xfrm_msg = msg_; |
| 646 | complete_rewrite = 1; |
| 647 | break; |
| 648 | } |
| 649 | /* fallthru */ |
| 650 | default: |
| 651 | xfrm_msg = NULL; |
| 652 | } |
| 653 | |
Junio C Hamano | 4130b99 | 2005-05-26 09:24:30 | [diff] [blame] | 654 | if (!pgm && |
| 655 | DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) && |
| 656 | (S_IFMT & one->mode) != (S_IFMT & two->mode)) { |
| 657 | /* a filepair that changes between file and symlink |
| 658 | * needs to be split into deletion and creation. |
| 659 | */ |
| 660 | struct diff_filespec *null = alloc_filespec(two->path); |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 661 | run_external_diff(NULL, name, other, one, null, xfrm_msg, 0); |
Junio C Hamano | 4130b99 | 2005-05-26 09:24:30 | [diff] [blame] | 662 | free(null); |
| 663 | null = alloc_filespec(one->path); |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 664 | run_external_diff(NULL, name, other, null, two, xfrm_msg, 0); |
Junio C Hamano | 4130b99 | 2005-05-26 09:24:30 | [diff] [blame] | 665 | free(null); |
| 666 | } |
| 667 | else |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 668 | run_external_diff(pgm, name, other, one, two, xfrm_msg, |
| 669 | complete_rewrite); |
Junio C Hamano | 4130b99 | 2005-05-26 09:24:30 | [diff] [blame] | 670 | } |
| 671 | |
Junio C Hamano | 19feebc | 2005-05-27 22:54:37 | [diff] [blame] | 672 | void diff_setup(int flags) |
Junio C Hamano | 5c97558 | 2005-05-19 10:32:35 | [diff] [blame] | 673 | { |
Junio C Hamano | 19feebc | 2005-05-27 22:54:37 | [diff] [blame] | 674 | if (flags & DIFF_SETUP_REVERSE) |
| 675 | reverse_diff = 1; |
Junio C Hamano | f0c6b2a | 2005-05-27 22:56:38 | [diff] [blame] | 676 | if (flags & DIFF_SETUP_USE_CACHE) { |
| 677 | if (!active_cache) |
| 678 | /* read-cache does not die even when it fails |
| 679 | * so it is safe for us to do this here. Also |
| 680 | * it does not smudge active_cache or active_nr |
| 681 | * when it fails, so we do not have to worry about |
| 682 | * cleaning it up oufselves either. |
| 683 | */ |
| 684 | read_cache(); |
| 685 | } |
| 686 | if (flags & DIFF_SETUP_USE_SIZE_CACHE) |
| 687 | use_size_cache = 1; |
| 688 | |
Junio C Hamano | 57fe64a | 2005-05-20 02:00:36 | [diff] [blame] | 689 | } |
| 690 | |
Junio C Hamano | 0e3994f | 2005-06-03 08:37:54 | [diff] [blame] | 691 | static int parse_num(const char **cp_p) |
| 692 | { |
| 693 | int num, scale, ch, cnt; |
| 694 | const char *cp = *cp_p; |
| 695 | |
| 696 | cnt = num = 0; |
| 697 | scale = 1; |
| 698 | while ('0' <= (ch = *cp) && ch <= '9') { |
| 699 | if (cnt++ < 5) { |
| 700 | /* We simply ignore more than 5 digits precision. */ |
| 701 | scale *= 10; |
| 702 | num = num * 10 + ch - '0'; |
| 703 | } |
Junio C Hamano | 5de36bf | 2005-08-30 04:17:21 | [diff] [blame] | 704 | cp++; |
Junio C Hamano | 0e3994f | 2005-06-03 08:37:54 | [diff] [blame] | 705 | } |
| 706 | *cp_p = cp; |
| 707 | |
| 708 | /* user says num divided by scale and we say internally that |
| 709 | * is MAX_SCORE * num / scale. |
| 710 | */ |
| 711 | return (MAX_SCORE * num / scale); |
| 712 | } |
| 713 | |
| 714 | int diff_scoreopt_parse(const char *opt) |
| 715 | { |
Junio C Hamano | eeaa460 | 2005-06-03 08:40:28 | [diff] [blame] | 716 | int opt1, opt2, cmd; |
Junio C Hamano | 0e3994f | 2005-06-03 08:37:54 | [diff] [blame] | 717 | |
| 718 | if (*opt++ != '-') |
| 719 | return -1; |
| 720 | cmd = *opt++; |
| 721 | if (cmd != 'M' && cmd != 'C' && cmd != 'B') |
| 722 | return -1; /* that is not a -M, -C nor -B option */ |
| 723 | |
| 724 | opt1 = parse_num(&opt); |
Junio C Hamano | eeaa460 | 2005-06-03 08:40:28 | [diff] [blame] | 725 | if (cmd != 'B') |
| 726 | opt2 = 0; |
| 727 | else { |
| 728 | if (*opt == 0) |
| 729 | opt2 = 0; |
| 730 | else if (*opt != '/') |
| 731 | return -1; /* we expect -B80/99 or -B80 */ |
| 732 | else { |
| 733 | opt++; |
| 734 | opt2 = parse_num(&opt); |
| 735 | } |
| 736 | } |
Junio C Hamano | 0e3994f | 2005-06-03 08:37:54 | [diff] [blame] | 737 | if (*opt != 0) |
| 738 | return -1; |
Junio C Hamano | eeaa460 | 2005-06-03 08:40:28 | [diff] [blame] | 739 | return opt1 | (opt2 << 16); |
Junio C Hamano | 0e3994f | 2005-06-03 08:37:54 | [diff] [blame] | 740 | } |
| 741 | |
Junio C Hamano | 38c6f78 | 2005-05-22 02:40:36 | [diff] [blame] | 742 | struct diff_queue_struct diff_queued_diff; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 743 | |
Junio C Hamano | 6b14d7f | 2005-05-22 17:04:37 | [diff] [blame] | 744 | void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp) |
| 745 | { |
| 746 | if (queue->alloc <= queue->nr) { |
| 747 | queue->alloc = alloc_nr(queue->alloc); |
| 748 | queue->queue = xrealloc(queue->queue, |
| 749 | sizeof(dp) * queue->alloc); |
| 750 | } |
| 751 | queue->queue[queue->nr++] = dp; |
| 752 | } |
| 753 | |
Junio C Hamano | 52e9578 | 2005-05-21 09:40:01 | [diff] [blame] | 754 | struct diff_filepair *diff_queue(struct diff_queue_struct *queue, |
Junio C Hamano | 6b14d7f | 2005-05-22 17:04:37 | [diff] [blame] | 755 | struct diff_filespec *one, |
| 756 | struct diff_filespec *two) |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 757 | { |
Junio C Hamano | 52e9578 | 2005-05-21 09:40:01 | [diff] [blame] | 758 | struct diff_filepair *dp = xmalloc(sizeof(*dp)); |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 759 | dp->one = one; |
| 760 | dp->two = two; |
Junio C Hamano | f7c1512 | 2005-05-23 04:26:09 | [diff] [blame] | 761 | dp->score = 0; |
Junio C Hamano | 2210100 | 2005-06-12 03:55:20 | [diff] [blame] | 762 | dp->status = 0; |
Junio C Hamano | 15d061b | 2005-05-27 22:55:55 | [diff] [blame] | 763 | dp->source_stays = 0; |
Junio C Hamano | f345b0a | 2005-05-30 07:08:37 | [diff] [blame] | 764 | dp->broken_pair = 0; |
Junio C Hamano | 5098baf | 2005-09-15 23:13:43 | [diff] [blame] | 765 | if (queue) |
| 766 | diff_q(queue, dp); |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 767 | return dp; |
| 768 | } |
| 769 | |
Junio C Hamano | 226406f | 2005-05-27 22:50:30 | [diff] [blame] | 770 | void diff_free_filepair(struct diff_filepair *p) |
| 771 | { |
Junio C Hamano | 19397b4 | 2005-09-14 21:06:50 | [diff] [blame] | 772 | diff_free_filespec_data(p->one); |
| 773 | diff_free_filespec_data(p->two); |
Junio C Hamano | 5098baf | 2005-09-15 23:13:43 | [diff] [blame] | 774 | free(p->one); |
| 775 | free(p->two); |
Junio C Hamano | 226406f | 2005-05-27 22:50:30 | [diff] [blame] | 776 | free(p); |
| 777 | } |
| 778 | |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 779 | static void diff_flush_raw(struct diff_filepair *p, |
| 780 | int line_termination, |
| 781 | int inter_name_termination) |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 782 | { |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 783 | int two_paths; |
| 784 | char status[10]; |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 785 | |
| 786 | if (line_termination) { |
Junio C Hamano | 79db12e | 2005-08-10 04:25:46 | [diff] [blame] | 787 | const char *const err = |
| 788 | "path %s cannot be expressed without -z"; |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 789 | if (strchr(p->one->path, line_termination) || |
| 790 | strchr(p->one->path, inter_name_termination)) |
| 791 | die(err, p->one->path); |
| 792 | if (strchr(p->two->path, line_termination) || |
| 793 | strchr(p->two->path, inter_name_termination)) |
| 794 | die(err, p->two->path); |
| 795 | } |
| 796 | |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 797 | if (p->score) |
| 798 | sprintf(status, "%c%03d", p->status, |
| 799 | (int)(0.5 + p->score * 100.0/MAX_SCORE)); |
| 800 | else { |
| 801 | status[0] = p->status; |
| 802 | status[1] = 0; |
| 803 | } |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 804 | switch (p->status) { |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 805 | case DIFF_STATUS_COPIED: |
| 806 | case DIFF_STATUS_RENAMED: |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 807 | two_paths = 1; |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 808 | break; |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 809 | case DIFF_STATUS_ADDED: |
| 810 | case DIFF_STATUS_DELETED: |
Junio C Hamano | f345b0a | 2005-05-30 07:08:37 | [diff] [blame] | 811 | two_paths = 0; |
Junio C Hamano | f345b0a | 2005-05-30 07:08:37 | [diff] [blame] | 812 | break; |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 813 | default: |
| 814 | two_paths = 0; |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 815 | break; |
Junio C Hamano | 6b14d7f | 2005-05-22 17:04:37 | [diff] [blame] | 816 | } |
Junio C Hamano | 81e50ea | 2005-05-22 02:42:18 | [diff] [blame] | 817 | printf(":%06o %06o %s ", |
| 818 | p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1)); |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 819 | printf("%s %s%c%s", |
| 820 | sha1_to_hex(p->two->sha1), |
| 821 | status, |
| 822 | inter_name_termination, |
| 823 | p->one->path); |
| 824 | if (two_paths) |
| 825 | printf("%c%s", inter_name_termination, p->two->path); |
| 826 | putchar(line_termination); |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 827 | } |
| 828 | |
Junio C Hamano | 52f2852 | 2005-07-13 19:45:51 | [diff] [blame] | 829 | static void diff_flush_name(struct diff_filepair *p, |
| 830 | int line_termination) |
| 831 | { |
| 832 | printf("%s%c", p->two->path, line_termination); |
| 833 | } |
| 834 | |
Junio C Hamano | f7c1512 | 2005-05-23 04:26:09 | [diff] [blame] | 835 | int diff_unmodified_pair(struct diff_filepair *p) |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 836 | { |
| 837 | /* This function is written stricter than necessary to support |
| 838 | * the currently implemented transformers, but the idea is to |
Junio C Hamano | 52e9578 | 2005-05-21 09:40:01 | [diff] [blame] | 839 | * let transformers to produce diff_filepairs any way they want, |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 840 | * and filter and clean them up here before producing the output. |
| 841 | */ |
Junio C Hamano | 6b14d7f | 2005-05-22 17:04:37 | [diff] [blame] | 842 | struct diff_filespec *one, *two; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 843 | |
Junio C Hamano | 6b14d7f | 2005-05-22 17:04:37 | [diff] [blame] | 844 | if (DIFF_PAIR_UNMERGED(p)) |
| 845 | return 0; /* unmerged is interesting */ |
| 846 | |
| 847 | one = p->one; |
| 848 | two = p->two; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 849 | |
Junio C Hamano | 4130b99 | 2005-05-26 09:24:30 | [diff] [blame] | 850 | /* deletion, addition, mode or type change |
| 851 | * and rename are all interesting. |
| 852 | */ |
Junio C Hamano | 81e50ea | 2005-05-22 02:42:18 | [diff] [blame] | 853 | if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) || |
Junio C Hamano | 4130b99 | 2005-05-26 09:24:30 | [diff] [blame] | 854 | DIFF_PAIR_MODE_CHANGED(p) || |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 855 | strcmp(one->path, two->path)) |
| 856 | return 0; |
| 857 | |
| 858 | /* both are valid and point at the same path. that is, we are |
| 859 | * dealing with a change. |
| 860 | */ |
| 861 | if (one->sha1_valid && two->sha1_valid && |
| 862 | !memcmp(one->sha1, two->sha1, sizeof(one->sha1))) |
| 863 | return 1; /* no change */ |
| 864 | if (!one->sha1_valid && !two->sha1_valid) |
| 865 | return 1; /* both look at the same file on the filesystem. */ |
| 866 | return 0; |
| 867 | } |
| 868 | |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 869 | static void diff_flush_patch(struct diff_filepair *p) |
Junio C Hamano | f7c1512 | 2005-05-23 04:26:09 | [diff] [blame] | 870 | { |
Junio C Hamano | f7c1512 | 2005-05-23 04:26:09 | [diff] [blame] | 871 | if (diff_unmodified_pair(p)) |
| 872 | return; |
| 873 | |
Junio C Hamano | f7c1512 | 2005-05-23 04:26:09 | [diff] [blame] | 874 | if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) || |
| 875 | (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode))) |
| 876 | return; /* no tree diffs in patch format */ |
| 877 | |
Junio C Hamano | 366175e | 2005-06-19 20:17:50 | [diff] [blame] | 878 | run_diff(p); |
Junio C Hamano | f7c1512 | 2005-05-23 04:26:09 | [diff] [blame] | 879 | } |
| 880 | |
Junio C Hamano | 38c6f78 | 2005-05-22 02:40:36 | [diff] [blame] | 881 | int diff_queue_is_empty(void) |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 882 | { |
Junio C Hamano | 38c6f78 | 2005-05-22 02:40:36 | [diff] [blame] | 883 | struct diff_queue_struct *q = &diff_queued_diff; |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 884 | int i; |
| 885 | for (i = 0; i < q->nr; i++) |
| 886 | if (!diff_unmodified_pair(q->queue[i])) |
| 887 | return 0; |
| 888 | return 1; |
Junio C Hamano | 38c6f78 | 2005-05-22 02:40:36 | [diff] [blame] | 889 | } |
| 890 | |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 891 | #if DIFF_DEBUG |
| 892 | void diff_debug_filespec(struct diff_filespec *s, int x, const char *one) |
| 893 | { |
| 894 | fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n", |
Jason Riedy | c7c81b3 | 2005-08-23 20:34:07 | [diff] [blame] | 895 | x, one ? one : "", |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 896 | s->path, |
| 897 | DIFF_FILE_VALID(s) ? "valid" : "invalid", |
| 898 | s->mode, |
| 899 | s->sha1_valid ? sha1_to_hex(s->sha1) : ""); |
| 900 | fprintf(stderr, "queue[%d] %s size %lu flags %d\n", |
Jason Riedy | c7c81b3 | 2005-08-23 20:34:07 | [diff] [blame] | 901 | x, one ? one : "", |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 902 | s->size, s->xfrm_flags); |
| 903 | } |
| 904 | |
| 905 | void diff_debug_filepair(const struct diff_filepair *p, int i) |
| 906 | { |
| 907 | diff_debug_filespec(p->one, i, "one"); |
| 908 | diff_debug_filespec(p->two, i, "two"); |
Junio C Hamano | f345b0a | 2005-05-30 07:08:37 | [diff] [blame] | 909 | fprintf(stderr, "score %d, status %c stays %d broken %d\n", |
Jason Riedy | c7c81b3 | 2005-08-23 20:34:07 | [diff] [blame] | 910 | p->score, p->status ? p->status : '?', |
Junio C Hamano | f345b0a | 2005-05-30 07:08:37 | [diff] [blame] | 911 | p->source_stays, p->broken_pair); |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 912 | } |
| 913 | |
| 914 | void diff_debug_queue(const char *msg, struct diff_queue_struct *q) |
| 915 | { |
| 916 | int i; |
| 917 | if (msg) |
| 918 | fprintf(stderr, "%s\n", msg); |
| 919 | fprintf(stderr, "q->nr = %d\n", q->nr); |
| 920 | for (i = 0; i < q->nr; i++) { |
| 921 | struct diff_filepair *p = q->queue[i]; |
| 922 | diff_debug_filepair(p, i); |
| 923 | } |
| 924 | } |
| 925 | #endif |
| 926 | |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 927 | static void diff_resolve_rename_copy(void) |
| 928 | { |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 929 | int i, j; |
| 930 | struct diff_filepair *p, *pp; |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 931 | struct diff_queue_struct *q = &diff_queued_diff; |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 932 | |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 933 | diff_debug_queue("resolve-rename-copy", q); |
| 934 | |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 935 | for (i = 0; i < q->nr; i++) { |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 936 | p = q->queue[i]; |
Junio C Hamano | 96716a1 | 2005-05-25 22:07:08 | [diff] [blame] | 937 | p->status = 0; /* undecided */ |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 938 | if (DIFF_PAIR_UNMERGED(p)) |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 939 | p->status = DIFF_STATUS_UNMERGED; |
Junio C Hamano | 15d061b | 2005-05-27 22:55:55 | [diff] [blame] | 940 | else if (!DIFF_FILE_VALID(p->one)) |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 941 | p->status = DIFF_STATUS_ADDED; |
Junio C Hamano | 2cd6888 | 2005-05-30 07:08:07 | [diff] [blame] | 942 | else if (!DIFF_FILE_VALID(p->two)) |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 943 | p->status = DIFF_STATUS_DELETED; |
Junio C Hamano | 96716a1 | 2005-05-25 22:07:08 | [diff] [blame] | 944 | else if (DIFF_PAIR_TYPE_CHANGED(p)) |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 945 | p->status = DIFF_STATUS_TYPE_CHANGED; |
Junio C Hamano | 96716a1 | 2005-05-25 22:07:08 | [diff] [blame] | 946 | |
| 947 | /* from this point on, we are dealing with a pair |
| 948 | * whose both sides are valid and of the same type, i.e. |
| 949 | * either in-place edit or rename/copy edit. |
| 950 | */ |
Junio C Hamano | 01c4e70 | 2005-05-29 23:56:48 | [diff] [blame] | 951 | else if (DIFF_PAIR_RENAME(p)) { |
Junio C Hamano | 15d061b | 2005-05-27 22:55:55 | [diff] [blame] | 952 | if (p->source_stays) { |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 953 | p->status = DIFF_STATUS_COPIED; |
Junio C Hamano | 15d061b | 2005-05-27 22:55:55 | [diff] [blame] | 954 | continue; |
| 955 | } |
| 956 | /* See if there is some other filepair that |
| 957 | * copies from the same source as us. If so |
Junio C Hamano | 6bac10d | 2005-09-10 19:42:32 | [diff] [blame] | 958 | * we are a copy. Otherwise we are either a |
| 959 | * copy if the path stays, or a rename if it |
| 960 | * does not, but we already handled "stays" case. |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 961 | */ |
Junio C Hamano | 15d061b | 2005-05-27 22:55:55 | [diff] [blame] | 962 | for (j = i + 1; j < q->nr; j++) { |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 963 | pp = q->queue[j]; |
| 964 | if (strcmp(pp->one->path, p->one->path)) |
Junio C Hamano | 15d061b | 2005-05-27 22:55:55 | [diff] [blame] | 965 | continue; /* not us */ |
Junio C Hamano | 01c4e70 | 2005-05-29 23:56:48 | [diff] [blame] | 966 | if (!DIFF_PAIR_RENAME(pp)) |
Junio C Hamano | 15d061b | 2005-05-27 22:55:55 | [diff] [blame] | 967 | continue; /* not a rename/copy */ |
| 968 | /* pp is a rename/copy from the same source */ |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 969 | p->status = DIFF_STATUS_COPIED; |
Junio C Hamano | 15d061b | 2005-05-27 22:55:55 | [diff] [blame] | 970 | break; |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 971 | } |
| 972 | if (!p->status) |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 973 | p->status = DIFF_STATUS_RENAMED; |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 974 | } |
Junio C Hamano | 9fdade0 | 2005-05-25 23:00:04 | [diff] [blame] | 975 | else if (memcmp(p->one->sha1, p->two->sha1, 20) || |
| 976 | p->one->mode != p->two->mode) |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 977 | p->status = DIFF_STATUS_MODIFIED; |
Junio C Hamano | 67574c4 | 2005-06-01 18:38:07 | [diff] [blame] | 978 | else { |
| 979 | /* This is a "no-change" entry and should not |
| 980 | * happen anymore, but prepare for broken callers. |
Junio C Hamano | 15d061b | 2005-05-27 22:55:55 | [diff] [blame] | 981 | */ |
Junio C Hamano | 67574c4 | 2005-06-01 18:38:07 | [diff] [blame] | 982 | error("feeding unmodified %s to diffcore", |
| 983 | p->one->path); |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 984 | p->status = DIFF_STATUS_UNKNOWN; |
Junio C Hamano | 67574c4 | 2005-06-01 18:38:07 | [diff] [blame] | 985 | } |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 986 | } |
Junio C Hamano | 25d5ea4 | 2005-05-24 08:10:48 | [diff] [blame] | 987 | diff_debug_queue("resolve-rename-copy done", q); |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 988 | } |
| 989 | |
Linus Torvalds | e68b6f1 | 2005-07-15 00:59:17 | [diff] [blame] | 990 | void diff_flush(int diff_output_style, int line_termination) |
Junio C Hamano | 38c6f78 | 2005-05-22 02:40:36 | [diff] [blame] | 991 | { |
| 992 | struct diff_queue_struct *q = &diff_queued_diff; |
| 993 | int i; |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 994 | int inter_name_termination = '\t'; |
Junio C Hamano | 38c6f78 | 2005-05-22 02:40:36 | [diff] [blame] | 995 | |
Linus Torvalds | e68b6f1 | 2005-07-15 00:59:17 | [diff] [blame] | 996 | if (!line_termination) |
| 997 | inter_name_termination = 0; |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 998 | |
Junio C Hamano | f7c1512 | 2005-05-23 04:26:09 | [diff] [blame] | 999 | for (i = 0; i < q->nr; i++) { |
Junio C Hamano | f7c1512 | 2005-05-23 04:26:09 | [diff] [blame] | 1000 | struct diff_filepair *p = q->queue[i]; |
Junio C Hamano | 4130b99 | 2005-05-26 09:24:30 | [diff] [blame] | 1001 | if ((diff_output_style == DIFF_FORMAT_NO_OUTPUT) || |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 1002 | (p->status == DIFF_STATUS_UNKNOWN)) |
Junio C Hamano | 96716a1 | 2005-05-25 22:07:08 | [diff] [blame] | 1003 | continue; |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 1004 | if (p->status == 0) |
Junio C Hamano | 96716a1 | 2005-05-25 22:07:08 | [diff] [blame] | 1005 | die("internal error in diff-resolve-rename-copy"); |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 1006 | switch (diff_output_style) { |
| 1007 | case DIFF_FORMAT_PATCH: |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 1008 | diff_flush_patch(p); |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 1009 | break; |
Linus Torvalds | e68b6f1 | 2005-07-15 00:59:17 | [diff] [blame] | 1010 | case DIFF_FORMAT_RAW: |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 1011 | diff_flush_raw(p, line_termination, |
| 1012 | inter_name_termination); |
| 1013 | break; |
Junio C Hamano | 52f2852 | 2005-07-13 19:45:51 | [diff] [blame] | 1014 | case DIFF_FORMAT_NAME: |
Junio C Hamano | 52f2852 | 2005-07-13 19:45:51 | [diff] [blame] | 1015 | diff_flush_name(p, line_termination); |
| 1016 | break; |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 1017 | } |
Junio C Hamano | 226406f | 2005-05-27 22:50:30 | [diff] [blame] | 1018 | diff_free_filepair(q->queue[i]); |
Yasushi SHOJI | 90a734d | 2005-08-21 07:14:16 | [diff] [blame] | 1019 | } |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 1020 | free(q->queue); |
| 1021 | q->queue = NULL; |
| 1022 | q->nr = q->alloc = 0; |
| 1023 | } |
| 1024 | |
Junio C Hamano | f2ce9fd | 2005-06-12 03:57:13 | [diff] [blame] | 1025 | static void diffcore_apply_filter(const char *filter) |
| 1026 | { |
| 1027 | int i; |
| 1028 | struct diff_queue_struct *q = &diff_queued_diff; |
| 1029 | struct diff_queue_struct outq; |
| 1030 | outq.queue = NULL; |
| 1031 | outq.nr = outq.alloc = 0; |
| 1032 | |
| 1033 | if (!filter) |
| 1034 | return; |
| 1035 | |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 1036 | if (strchr(filter, DIFF_STATUS_FILTER_AON)) { |
Junio C Hamano | f2ce9fd | 2005-06-12 03:57:13 | [diff] [blame] | 1037 | int found; |
| 1038 | for (i = found = 0; !found && i < q->nr; i++) { |
| 1039 | struct diff_filepair *p = q->queue[i]; |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 1040 | if (((p->status == DIFF_STATUS_MODIFIED) && |
| 1041 | ((p->score && |
| 1042 | strchr(filter, DIFF_STATUS_FILTER_BROKEN)) || |
| 1043 | (!p->score && |
| 1044 | strchr(filter, DIFF_STATUS_MODIFIED)))) || |
| 1045 | ((p->status != DIFF_STATUS_MODIFIED) && |
| 1046 | strchr(filter, p->status))) |
Junio C Hamano | f2ce9fd | 2005-06-12 03:57:13 | [diff] [blame] | 1047 | found++; |
| 1048 | } |
| 1049 | if (found) |
| 1050 | return; |
| 1051 | |
| 1052 | /* otherwise we will clear the whole queue |
| 1053 | * by copying the empty outq at the end of this |
| 1054 | * function, but first clear the current entries |
| 1055 | * in the queue. |
| 1056 | */ |
| 1057 | for (i = 0; i < q->nr; i++) |
| 1058 | diff_free_filepair(q->queue[i]); |
| 1059 | } |
| 1060 | else { |
| 1061 | /* Only the matching ones */ |
| 1062 | for (i = 0; i < q->nr; i++) { |
| 1063 | struct diff_filepair *p = q->queue[i]; |
Junio C Hamano | e7baa4f | 2005-07-25 20:05:44 | [diff] [blame] | 1064 | |
| 1065 | if (((p->status == DIFF_STATUS_MODIFIED) && |
| 1066 | ((p->score && |
| 1067 | strchr(filter, DIFF_STATUS_FILTER_BROKEN)) || |
| 1068 | (!p->score && |
| 1069 | strchr(filter, DIFF_STATUS_MODIFIED)))) || |
| 1070 | ((p->status != DIFF_STATUS_MODIFIED) && |
| 1071 | strchr(filter, p->status))) |
Junio C Hamano | f2ce9fd | 2005-06-12 03:57:13 | [diff] [blame] | 1072 | diff_q(&outq, p); |
| 1073 | else |
| 1074 | diff_free_filepair(p); |
| 1075 | } |
| 1076 | } |
| 1077 | free(q->queue); |
| 1078 | *q = outq; |
| 1079 | } |
| 1080 | |
Junio C Hamano | befe863 | 2005-05-29 23:56:13 | [diff] [blame] | 1081 | void diffcore_std(const char **paths, |
| 1082 | int detect_rename, int rename_score, |
Junio C Hamano | f345b0a | 2005-05-30 07:08:37 | [diff] [blame] | 1083 | const char *pickaxe, int pickaxe_opts, |
Junio C Hamano | af5323e | 2005-05-30 07:09:07 | [diff] [blame] | 1084 | int break_opt, |
Junio C Hamano | f2ce9fd | 2005-06-12 03:57:13 | [diff] [blame] | 1085 | const char *orderfile, |
| 1086 | const char *filter) |
Junio C Hamano | befe863 | 2005-05-29 23:56:13 | [diff] [blame] | 1087 | { |
| 1088 | if (paths && paths[0]) |
| 1089 | diffcore_pathspec(paths); |
Junio C Hamano | 49d9e85 | 2005-06-04 06:04:07 | [diff] [blame] | 1090 | if (break_opt != -1) |
Junio C Hamano | f345b0a | 2005-05-30 07:08:37 | [diff] [blame] | 1091 | diffcore_break(break_opt); |
Junio C Hamano | befe863 | 2005-05-29 23:56:13 | [diff] [blame] | 1092 | if (detect_rename) |
| 1093 | diffcore_rename(detect_rename, rename_score); |
Junio C Hamano | 49d9e85 | 2005-06-04 06:04:07 | [diff] [blame] | 1094 | if (break_opt != -1) |
Junio C Hamano | eeaa460 | 2005-06-03 08:40:28 | [diff] [blame] | 1095 | diffcore_merge_broken(); |
Junio C Hamano | befe863 | 2005-05-29 23:56:13 | [diff] [blame] | 1096 | if (pickaxe) |
| 1097 | diffcore_pickaxe(pickaxe, pickaxe_opts); |
Junio C Hamano | af5323e | 2005-05-30 07:09:07 | [diff] [blame] | 1098 | if (orderfile) |
| 1099 | diffcore_order(orderfile); |
Junio C Hamano | f2ce9fd | 2005-06-12 03:57:13 | [diff] [blame] | 1100 | diff_resolve_rename_copy(); |
| 1101 | diffcore_apply_filter(filter); |
| 1102 | } |
| 1103 | |
| 1104 | |
| 1105 | void diffcore_std_no_resolve(const char **paths, |
| 1106 | const char *pickaxe, int pickaxe_opts, |
| 1107 | const char *orderfile, |
| 1108 | const char *filter) |
| 1109 | { |
| 1110 | if (paths && paths[0]) |
| 1111 | diffcore_pathspec(paths); |
| 1112 | if (pickaxe) |
| 1113 | diffcore_pickaxe(pickaxe, pickaxe_opts); |
| 1114 | if (orderfile) |
| 1115 | diffcore_order(orderfile); |
| 1116 | diffcore_apply_filter(filter); |
Junio C Hamano | befe863 | 2005-05-29 23:56:13 | [diff] [blame] | 1117 | } |
| 1118 | |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 1119 | void diff_addremove(int addremove, unsigned mode, |
| 1120 | const unsigned char *sha1, |
| 1121 | const char *base, const char *path) |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 1122 | { |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 1123 | char concatpath[PATH_MAX]; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 1124 | struct diff_filespec *one, *two; |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 1125 | |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 1126 | /* This may look odd, but it is a preparation for |
| 1127 | * feeding "there are unchanged files which should |
| 1128 | * not produce diffs, but when you are doing copy |
| 1129 | * detection you would need them, so here they are" |
| 1130 | * entries to the diff-core. They will be prefixed |
| 1131 | * with something like '=' or '*' (I haven't decided |
| 1132 | * which but should not make any difference). |
Junio C Hamano | f7c1512 | 2005-05-23 04:26:09 | [diff] [blame] | 1133 | * Feeding the same new and old to diff_change() |
Junio C Hamano | bceafe7 | 2005-05-24 01:14:03 | [diff] [blame] | 1134 | * also has the same effect. |
| 1135 | * Before the final output happens, they are pruned after |
| 1136 | * merged into rename/copy pairs as appropriate. |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 1137 | */ |
Junio C Hamano | 7ca4525 | 2005-05-20 16:54:07 | [diff] [blame] | 1138 | if (reverse_diff) |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 1139 | addremove = (addremove == '+' ? '-' : |
| 1140 | addremove == '-' ? '+' : addremove); |
Junio C Hamano | 7ca4525 | 2005-05-20 16:54:07 | [diff] [blame] | 1141 | |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 1142 | if (!path) path = ""; |
| 1143 | sprintf(concatpath, "%s%s", base, path); |
| 1144 | one = alloc_filespec(concatpath); |
| 1145 | two = alloc_filespec(concatpath); |
Junio C Hamano | 57fe64a | 2005-05-20 02:00:36 | [diff] [blame] | 1146 | |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 1147 | if (addremove != '+') |
| 1148 | fill_filespec(one, sha1, mode); |
| 1149 | if (addremove != '-') |
| 1150 | fill_filespec(two, sha1, mode); |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 1151 | |
Junio C Hamano | 38c6f78 | 2005-05-22 02:40:36 | [diff] [blame] | 1152 | diff_queue(&diff_queued_diff, one, two); |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 1153 | } |
| 1154 | |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 1155 | void diff_helper_input(unsigned old_mode, |
| 1156 | unsigned new_mode, |
| 1157 | const unsigned char *old_sha1, |
| 1158 | const unsigned char *new_sha1, |
| 1159 | const char *old_path, |
| 1160 | int status, |
| 1161 | int score, |
| 1162 | const char *new_path) |
Junio C Hamano | 81e50ea | 2005-05-22 02:42:18 | [diff] [blame] | 1163 | { |
| 1164 | struct diff_filespec *one, *two; |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 1165 | struct diff_filepair *dp; |
Junio C Hamano | 81e50ea | 2005-05-22 02:42:18 | [diff] [blame] | 1166 | |
Junio C Hamano | 81e50ea | 2005-05-22 02:42:18 | [diff] [blame] | 1167 | one = alloc_filespec(old_path); |
| 1168 | two = alloc_filespec(new_path); |
| 1169 | if (old_mode) |
| 1170 | fill_filespec(one, old_sha1, old_mode); |
| 1171 | if (new_mode) |
| 1172 | fill_filespec(two, new_sha1, new_mode); |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 1173 | dp = diff_queue(&diff_queued_diff, one, two); |
Junio C Hamano | 903d475 | 2005-05-27 22:53:31 | [diff] [blame] | 1174 | dp->score = score * MAX_SCORE / 100; |
Junio C Hamano | b6d8f30 | 2005-05-23 21:55:33 | [diff] [blame] | 1175 | dp->status = status; |
Junio C Hamano | 81e50ea | 2005-05-22 02:42:18 | [diff] [blame] | 1176 | } |
| 1177 | |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 1178 | void diff_change(unsigned old_mode, unsigned new_mode, |
| 1179 | const unsigned char *old_sha1, |
| 1180 | const unsigned char *new_sha1, |
Junio C Hamano | 81e50ea | 2005-05-22 02:42:18 | [diff] [blame] | 1181 | const char *base, const char *path) |
| 1182 | { |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 1183 | char concatpath[PATH_MAX]; |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 1184 | struct diff_filespec *one, *two; |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 1185 | |
Junio C Hamano | 7ca4525 | 2005-05-20 16:54:07 | [diff] [blame] | 1186 | if (reverse_diff) { |
| 1187 | unsigned tmp; |
| 1188 | const unsigned char *tmp_c; |
| 1189 | tmp = old_mode; old_mode = new_mode; new_mode = tmp; |
| 1190 | tmp_c = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_c; |
| 1191 | } |
Junio C Hamano | 427dcb4 | 2005-05-21 09:39:09 | [diff] [blame] | 1192 | if (!path) path = ""; |
| 1193 | sprintf(concatpath, "%s%s", base, path); |
| 1194 | one = alloc_filespec(concatpath); |
| 1195 | two = alloc_filespec(concatpath); |
| 1196 | fill_filespec(one, old_sha1, old_mode); |
| 1197 | fill_filespec(two, new_sha1, new_mode); |
Junio C Hamano | 7ca4525 | 2005-05-20 16:54:07 | [diff] [blame] | 1198 | |
Junio C Hamano | 38c6f78 | 2005-05-22 02:40:36 | [diff] [blame] | 1199 | diff_queue(&diff_queued_diff, one, two); |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 1200 | } |
Junio C Hamano | be3cfa8 | 2005-04-26 16:25:05 | [diff] [blame] | 1201 | |
Junio C Hamano | 77eb272 | 2005-04-27 16:21:00 | [diff] [blame] | 1202 | void diff_unmerge(const char *path) |
| 1203 | { |
Junio C Hamano | 6b14d7f | 2005-05-22 17:04:37 | [diff] [blame] | 1204 | struct diff_filespec *one, *two; |
| 1205 | one = alloc_filespec(path); |
| 1206 | two = alloc_filespec(path); |
| 1207 | diff_queue(&diff_queued_diff, one, two); |
Junio C Hamano | 86436c2 | 2005-04-26 01:22:47 | [diff] [blame] | 1208 | } |