Junio C Hamano | 8f1d2e6 | 2006-01-07 01:33:54 -0800 | [diff] [blame] | 1 | #include "cache.h" |
Linus Torvalds | 961784e | 2005-05-18 16:14:22 -0700 | [diff] [blame] | 2 | #include "tag.h" |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 3 | #include "commit.h" |
Johannes Schindelin | ed09aef | 2006-10-30 20:09:06 +0100 | [diff] [blame] | 4 | #include "pkt-line.h" |
Junio C Hamano | 52883fb | 2006-12-25 11:48:35 -0800 | [diff] [blame] | 5 | #include "utf8.h" |
Junio C Hamano | 199c45b | 2007-04-09 02:34:05 -0700 | [diff] [blame] | 6 | #include "diff.h" |
| 7 | #include "revision.h" |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 8 | |
Linus Torvalds | 60ab26d | 2005-09-15 14:43:17 -0700 | [diff] [blame] | 9 | int save_commit_buffer = 1; |
| 10 | |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 11 | const char *commit_type = "commit"; |
| 12 | |
Junio C Hamano | f76412e | 2005-08-21 02:51:10 -0700 | [diff] [blame] | 13 | static struct commit *check_commit(struct object *obj, |
| 14 | const unsigned char *sha1, |
| 15 | int quiet) |
Linus Torvalds | 961784e | 2005-05-18 16:14:22 -0700 | [diff] [blame] | 16 | { |
Linus Torvalds | 1974632 | 2006-07-11 20:45:31 -0700 | [diff] [blame] | 17 | if (obj->type != OBJ_COMMIT) { |
Junio C Hamano | f76412e | 2005-08-21 02:51:10 -0700 | [diff] [blame] | 18 | if (!quiet) |
| 19 | error("Object %s is a %s, not a commit", |
Linus Torvalds | 885a86a | 2006-06-14 16:45:13 -0700 | [diff] [blame] | 20 | sha1_to_hex(sha1), typename(obj->type)); |
Linus Torvalds | 961784e | 2005-05-18 16:14:22 -0700 | [diff] [blame] | 21 | return NULL; |
| 22 | } |
| 23 | return (struct commit *) obj; |
| 24 | } |
| 25 | |
Junio C Hamano | f76412e | 2005-08-21 02:51:10 -0700 | [diff] [blame] | 26 | struct commit *lookup_commit_reference_gently(const unsigned char *sha1, |
| 27 | int quiet) |
Linus Torvalds | 961784e | 2005-05-18 16:14:22 -0700 | [diff] [blame] | 28 | { |
Junio C Hamano | 9534f40 | 2005-11-02 15:19:13 -0800 | [diff] [blame] | 29 | struct object *obj = deref_tag(parse_object(sha1), NULL, 0); |
Linus Torvalds | 961784e | 2005-05-18 16:14:22 -0700 | [diff] [blame] | 30 | |
| 31 | if (!obj) |
| 32 | return NULL; |
Junio C Hamano | f76412e | 2005-08-21 02:51:10 -0700 | [diff] [blame] | 33 | return check_commit(obj, sha1, quiet); |
| 34 | } |
| 35 | |
| 36 | struct commit *lookup_commit_reference(const unsigned char *sha1) |
| 37 | { |
| 38 | return lookup_commit_reference_gently(sha1, 0); |
Linus Torvalds | 961784e | 2005-05-18 16:14:22 -0700 | [diff] [blame] | 39 | } |
| 40 | |
Jason McMullan | 5d6ccf5 | 2005-06-03 11:05:39 -0400 | [diff] [blame] | 41 | struct commit *lookup_commit(const unsigned char *sha1) |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 42 | { |
| 43 | struct object *obj = lookup_object(sha1); |
Linus Torvalds | 100c5f3 | 2007-04-16 22:11:43 -0700 | [diff] [blame] | 44 | if (!obj) |
| 45 | return create_object(sha1, OBJ_COMMIT, alloc_commit_node()); |
Nicolas Pitre | d1af002 | 2005-05-20 16:59:17 -0400 | [diff] [blame] | 46 | if (!obj->type) |
Linus Torvalds | 1974632 | 2006-07-11 20:45:31 -0700 | [diff] [blame] | 47 | obj->type = OBJ_COMMIT; |
Junio C Hamano | f76412e | 2005-08-21 02:51:10 -0700 | [diff] [blame] | 48 | return check_commit(obj, sha1, 0); |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 49 | } |
| 50 | |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 51 | static unsigned long parse_commit_date(const char *buf, const char *tail) |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 52 | { |
| 53 | unsigned long date; |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 54 | const char *dateptr; |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 55 | |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 56 | if (buf + 6 >= tail) |
| 57 | return 0; |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 58 | if (memcmp(buf, "author", 6)) |
| 59 | return 0; |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 60 | while (buf < tail && *buf++ != '\n') |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 61 | /* nada */; |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 62 | if (buf + 9 >= tail) |
| 63 | return 0; |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 64 | if (memcmp(buf, "committer", 9)) |
| 65 | return 0; |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 66 | while (buf < tail && *buf++ != '>') |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 67 | /* nada */; |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 68 | if (buf >= tail) |
| 69 | return 0; |
| 70 | dateptr = buf; |
| 71 | while (buf < tail && *buf++ != '\n') |
| 72 | /* nada */; |
| 73 | if (buf >= tail) |
| 74 | return 0; |
| 75 | /* dateptr < buf && buf[-1] == '\n', so strtoul will stop at buf-1 */ |
| 76 | date = strtoul(dateptr, NULL, 10); |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 77 | if (date == ULONG_MAX) |
| 78 | date = 0; |
| 79 | return date; |
| 80 | } |
| 81 | |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 82 | static struct commit_graft **commit_graft; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 83 | static int commit_graft_alloc, commit_graft_nr; |
| 84 | |
| 85 | static int commit_graft_pos(const unsigned char *sha1) |
| 86 | { |
| 87 | int lo, hi; |
| 88 | lo = 0; |
| 89 | hi = commit_graft_nr; |
| 90 | while (lo < hi) { |
| 91 | int mi = (lo + hi) / 2; |
| 92 | struct commit_graft *graft = commit_graft[mi]; |
David Rientjes | a89fccd | 2006-08-17 11:54:57 -0700 | [diff] [blame] | 93 | int cmp = hashcmp(sha1, graft->sha1); |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 94 | if (!cmp) |
| 95 | return mi; |
| 96 | if (cmp < 0) |
| 97 | hi = mi; |
| 98 | else |
| 99 | lo = mi + 1; |
| 100 | } |
| 101 | return -lo - 1; |
| 102 | } |
| 103 | |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 104 | int register_commit_graft(struct commit_graft *graft, int ignore_dups) |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 105 | { |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 106 | int pos = commit_graft_pos(graft->sha1); |
Junio C Hamano | a6080a0 | 2007-06-07 00:04:01 -0700 | [diff] [blame] | 107 | |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 108 | if (0 <= pos) { |
| 109 | if (ignore_dups) |
| 110 | free(graft); |
| 111 | else { |
| 112 | free(commit_graft[pos]); |
| 113 | commit_graft[pos] = graft; |
| 114 | } |
| 115 | return 1; |
| 116 | } |
| 117 | pos = -pos - 1; |
| 118 | if (commit_graft_alloc <= ++commit_graft_nr) { |
| 119 | commit_graft_alloc = alloc_nr(commit_graft_alloc); |
| 120 | commit_graft = xrealloc(commit_graft, |
| 121 | sizeof(*commit_graft) * |
| 122 | commit_graft_alloc); |
| 123 | } |
| 124 | if (pos < commit_graft_nr) |
| 125 | memmove(commit_graft + pos + 1, |
| 126 | commit_graft + pos, |
| 127 | (commit_graft_nr - pos - 1) * |
| 128 | sizeof(*commit_graft)); |
| 129 | commit_graft[pos] = graft; |
| 130 | return 0; |
| 131 | } |
| 132 | |
| 133 | struct commit_graft *read_graft_line(char *buf, int len) |
| 134 | { |
| 135 | /* The format is just "Commit Parent1 Parent2 ...\n" */ |
| 136 | int i; |
| 137 | struct commit_graft *graft = NULL; |
| 138 | |
| 139 | if (buf[len-1] == '\n') |
| 140 | buf[--len] = 0; |
Yann Dirson | 360204c | 2006-04-17 13:41:49 +0200 | [diff] [blame] | 141 | if (buf[0] == '#' || buf[0] == '\0') |
Junio C Hamano | 5bc4ce5 | 2006-04-16 14:24:56 -0700 | [diff] [blame] | 142 | return NULL; |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 143 | if ((len + 1) % 41) { |
| 144 | bad_graft_data: |
| 145 | error("bad graft data: %s", buf); |
| 146 | free(graft); |
| 147 | return NULL; |
| 148 | } |
| 149 | i = (len + 1) / 41 - 1; |
| 150 | graft = xmalloc(sizeof(*graft) + 20 * i); |
| 151 | graft->nr_parent = i; |
| 152 | if (get_sha1_hex(buf, graft->sha1)) |
| 153 | goto bad_graft_data; |
| 154 | for (i = 40; i < len; i += 41) { |
| 155 | if (buf[i] != ' ') |
| 156 | goto bad_graft_data; |
| 157 | if (get_sha1_hex(buf + i + 1, graft->parent[i/41])) |
| 158 | goto bad_graft_data; |
| 159 | } |
| 160 | return graft; |
| 161 | } |
| 162 | |
| 163 | int read_graft_file(const char *graft_file) |
| 164 | { |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 165 | FILE *fp = fopen(graft_file, "r"); |
| 166 | char buf[1024]; |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 167 | if (!fp) |
| 168 | return -1; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 169 | while (fgets(buf, sizeof(buf), fp)) { |
| 170 | /* The format is just "Commit Parent1 Parent2 ...\n" */ |
| 171 | int len = strlen(buf); |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 172 | struct commit_graft *graft = read_graft_line(buf, len); |
Junio C Hamano | 5bc4ce5 | 2006-04-16 14:24:56 -0700 | [diff] [blame] | 173 | if (!graft) |
| 174 | continue; |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 175 | if (register_commit_graft(graft, 1)) |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 176 | error("duplicate graft data: %s", buf); |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 177 | } |
| 178 | fclose(fp); |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 179 | return 0; |
| 180 | } |
| 181 | |
| 182 | static void prepare_commit_graft(void) |
| 183 | { |
| 184 | static int commit_graft_prepared; |
| 185 | char *graft_file; |
| 186 | |
| 187 | if (commit_graft_prepared) |
| 188 | return; |
| 189 | graft_file = get_graft_file(); |
| 190 | read_graft_file(graft_file); |
Johannes Schindelin | ed09aef | 2006-10-30 20:09:06 +0100 | [diff] [blame] | 191 | /* make sure shallows are read */ |
| 192 | is_repository_shallow(); |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 193 | commit_graft_prepared = 1; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 194 | } |
| 195 | |
Martin Koegler | 4516338 | 2008-02-25 22:46:07 +0100 | [diff] [blame] | 196 | struct commit_graft *lookup_commit_graft(const unsigned char *sha1) |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 197 | { |
| 198 | int pos; |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 199 | prepare_commit_graft(); |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 200 | pos = commit_graft_pos(sha1); |
| 201 | if (pos < 0) |
| 202 | return NULL; |
| 203 | return commit_graft[pos]; |
| 204 | } |
| 205 | |
Johannes Schindelin | ed09aef | 2006-10-30 20:09:06 +0100 | [diff] [blame] | 206 | int write_shallow_commits(int fd, int use_pack_protocol) |
| 207 | { |
| 208 | int i, count = 0; |
| 209 | for (i = 0; i < commit_graft_nr; i++) |
| 210 | if (commit_graft[i]->nr_parent < 0) { |
| 211 | const char *hex = |
| 212 | sha1_to_hex(commit_graft[i]->sha1); |
| 213 | count++; |
| 214 | if (use_pack_protocol) |
| 215 | packet_write(fd, "shallow %s", hex); |
| 216 | else { |
Andy Whitcroft | 93822c2 | 2007-01-08 15:58:23 +0000 | [diff] [blame] | 217 | if (write_in_full(fd, hex, 40) != 40) |
| 218 | break; |
| 219 | if (write_in_full(fd, "\n", 1) != 1) |
| 220 | break; |
Johannes Schindelin | ed09aef | 2006-10-30 20:09:06 +0100 | [diff] [blame] | 221 | } |
| 222 | } |
| 223 | return count; |
| 224 | } |
| 225 | |
Johannes Schindelin | f53514b | 2006-10-30 20:09:53 +0100 | [diff] [blame] | 226 | int unregister_shallow(const unsigned char *sha1) |
| 227 | { |
| 228 | int pos = commit_graft_pos(sha1); |
| 229 | if (pos < 0) |
| 230 | return -1; |
| 231 | if (pos + 1 < commit_graft_nr) |
| 232 | memcpy(commit_graft + pos, commit_graft + pos + 1, |
| 233 | sizeof(struct commit_graft *) |
| 234 | * (commit_graft_nr - pos - 1)); |
| 235 | commit_graft_nr--; |
| 236 | return 0; |
| 237 | } |
| 238 | |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 239 | int parse_commit_buffer(struct commit *item, void *buffer, unsigned long size) |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 240 | { |
Junio C Hamano | 3b44f15 | 2006-06-28 03:51:00 -0700 | [diff] [blame] | 241 | char *tail = buffer; |
Linus Torvalds | f7cc77d | 2005-07-27 15:12:48 -0700 | [diff] [blame] | 242 | char *bufptr = buffer; |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 243 | unsigned char parent[20]; |
Linus Torvalds | 6c88be1 | 2005-06-20 20:26:03 -0700 | [diff] [blame] | 244 | struct commit_list **pptr; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 245 | struct commit_graft *graft; |
Junio C Hamano | 27dedf0 | 2005-11-16 21:32:44 -0800 | [diff] [blame] | 246 | unsigned n_refs = 0; |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 247 | |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 248 | if (item->object.parsed) |
| 249 | return 0; |
| 250 | item->object.parsed = 1; |
Junio C Hamano | 3b44f15 | 2006-06-28 03:51:00 -0700 | [diff] [blame] | 251 | tail += size; |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 252 | if (tail <= bufptr + 46 || memcmp(bufptr, "tree ", 5) || bufptr[45] != '\n') |
Linus Torvalds | f7cc77d | 2005-07-27 15:12:48 -0700 | [diff] [blame] | 253 | return error("bogus commit object %s", sha1_to_hex(item->object.sha1)); |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 254 | if (get_sha1_hex(bufptr + 5, parent) < 0) |
Junio C Hamano | bd2afde | 2006-02-22 17:47:10 -0800 | [diff] [blame] | 255 | return error("bad tree pointer in commit %s", |
| 256 | sha1_to_hex(item->object.sha1)); |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 257 | item->tree = lookup_tree(parent); |
Linus Torvalds | 235ac40 | 2005-04-24 14:31:57 -0700 | [diff] [blame] | 258 | if (item->tree) |
Junio C Hamano | 27dedf0 | 2005-11-16 21:32:44 -0800 | [diff] [blame] | 259 | n_refs++; |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 260 | bufptr += 46; /* "tree " + "hex sha1" + "\n" */ |
Linus Torvalds | 6c88be1 | 2005-06-20 20:26:03 -0700 | [diff] [blame] | 261 | pptr = &item->parents; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 262 | |
| 263 | graft = lookup_commit_graft(item->object.sha1); |
Junio C Hamano | 3b44f15 | 2006-06-28 03:51:00 -0700 | [diff] [blame] | 264 | while (bufptr + 48 < tail && !memcmp(bufptr, "parent ", 7)) { |
Linus Torvalds | f7cc77d | 2005-07-27 15:12:48 -0700 | [diff] [blame] | 265 | struct commit *new_parent; |
| 266 | |
Junio C Hamano | 3b44f15 | 2006-06-28 03:51:00 -0700 | [diff] [blame] | 267 | if (tail <= bufptr + 48 || |
| 268 | get_sha1_hex(bufptr + 7, parent) || |
| 269 | bufptr[47] != '\n') |
Linus Torvalds | f7cc77d | 2005-07-27 15:12:48 -0700 | [diff] [blame] | 270 | return error("bad parents in commit %s", sha1_to_hex(item->object.sha1)); |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 271 | bufptr += 48; |
| 272 | if (graft) |
| 273 | continue; |
Linus Torvalds | f7cc77d | 2005-07-27 15:12:48 -0700 | [diff] [blame] | 274 | new_parent = lookup_commit(parent); |
Linus Torvalds | 235ac40 | 2005-04-24 14:31:57 -0700 | [diff] [blame] | 275 | if (new_parent) { |
Linus Torvalds | 6c88be1 | 2005-06-20 20:26:03 -0700 | [diff] [blame] | 276 | pptr = &commit_list_insert(new_parent, pptr)->next; |
Junio C Hamano | 27dedf0 | 2005-11-16 21:32:44 -0800 | [diff] [blame] | 277 | n_refs++; |
Linus Torvalds | 235ac40 | 2005-04-24 14:31:57 -0700 | [diff] [blame] | 278 | } |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 279 | } |
| 280 | if (graft) { |
| 281 | int i; |
| 282 | struct commit *new_parent; |
| 283 | for (i = 0; i < graft->nr_parent; i++) { |
| 284 | new_parent = lookup_commit(graft->parent[i]); |
| 285 | if (!new_parent) |
| 286 | continue; |
| 287 | pptr = &commit_list_insert(new_parent, pptr)->next; |
Junio C Hamano | 27dedf0 | 2005-11-16 21:32:44 -0800 | [diff] [blame] | 288 | n_refs++; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 289 | } |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 290 | } |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 291 | item->date = parse_commit_date(bufptr, tail); |
Junio C Hamano | 27dedf0 | 2005-11-16 21:32:44 -0800 | [diff] [blame] | 292 | |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 293 | return 0; |
| 294 | } |
| 295 | |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 296 | int parse_commit(struct commit *item) |
| 297 | { |
Nicolas Pitre | 21666f1 | 2007-02-26 14:55:59 -0500 | [diff] [blame] | 298 | enum object_type type; |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 299 | void *buffer; |
| 300 | unsigned long size; |
| 301 | int ret; |
| 302 | |
Martin Koegler | 9786f68 | 2008-02-18 21:48:02 +0100 | [diff] [blame] | 303 | if (!item) |
| 304 | return -1; |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 305 | if (item->object.parsed) |
| 306 | return 0; |
Nicolas Pitre | 21666f1 | 2007-02-26 14:55:59 -0500 | [diff] [blame] | 307 | buffer = read_sha1_file(item->object.sha1, &type, &size); |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 308 | if (!buffer) |
| 309 | return error("Could not read %s", |
| 310 | sha1_to_hex(item->object.sha1)); |
Nicolas Pitre | 21666f1 | 2007-02-26 14:55:59 -0500 | [diff] [blame] | 311 | if (type != OBJ_COMMIT) { |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 312 | free(buffer); |
| 313 | return error("Object %s not a commit", |
| 314 | sha1_to_hex(item->object.sha1)); |
| 315 | } |
| 316 | ret = parse_commit_buffer(item, buffer, size); |
Linus Torvalds | 60ab26d | 2005-09-15 14:43:17 -0700 | [diff] [blame] | 317 | if (save_commit_buffer && !ret) { |
Linus Torvalds | 3ff1fbb | 2005-05-25 18:27:14 -0700 | [diff] [blame] | 318 | item->buffer = buffer; |
| 319 | return 0; |
| 320 | } |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 321 | free(buffer); |
| 322 | return ret; |
| 323 | } |
| 324 | |
Linus Torvalds | ac5155e | 2005-05-30 18:44:02 -0700 | [diff] [blame] | 325 | struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p) |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 326 | { |
Christopher Li | 812666c | 2005-04-26 12:00:58 -0700 | [diff] [blame] | 327 | struct commit_list *new_list = xmalloc(sizeof(struct commit_list)); |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 328 | new_list->item = item; |
| 329 | new_list->next = *list_p; |
| 330 | *list_p = new_list; |
Linus Torvalds | ac5155e | 2005-05-30 18:44:02 -0700 | [diff] [blame] | 331 | return new_list; |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 332 | } |
| 333 | |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 334 | void free_commit_list(struct commit_list *list) |
| 335 | { |
| 336 | while (list) { |
| 337 | struct commit_list *temp = list; |
| 338 | list = temp->next; |
| 339 | free(temp); |
| 340 | } |
| 341 | } |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 342 | |
Linus Torvalds | f755494 | 2005-07-06 09:31:17 -0700 | [diff] [blame] | 343 | struct commit_list * insert_by_date(struct commit *item, struct commit_list **list) |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 344 | { |
| 345 | struct commit_list **pp = list; |
| 346 | struct commit_list *p; |
| 347 | while ((p = *pp) != NULL) { |
| 348 | if (p->item->date < item->date) { |
| 349 | break; |
| 350 | } |
| 351 | pp = &p->next; |
| 352 | } |
Linus Torvalds | f755494 | 2005-07-06 09:31:17 -0700 | [diff] [blame] | 353 | return commit_list_insert(item, pp); |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 354 | } |
| 355 | |
Junio C Hamano | a6080a0 | 2007-06-07 00:04:01 -0700 | [diff] [blame] | 356 | |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 357 | void sort_by_date(struct commit_list **list) |
| 358 | { |
| 359 | struct commit_list *ret = NULL; |
| 360 | while (*list) { |
Linus Torvalds | f755494 | 2005-07-06 09:31:17 -0700 | [diff] [blame] | 361 | insert_by_date((*list)->item, &ret); |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 362 | *list = (*list)->next; |
| 363 | } |
| 364 | *list = ret; |
| 365 | } |
| 366 | |
Daniel Barkalow | 58e28af | 2005-04-23 20:29:22 -0700 | [diff] [blame] | 367 | struct commit *pop_most_recent_commit(struct commit_list **list, |
| 368 | unsigned int mark) |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 369 | { |
| 370 | struct commit *ret = (*list)->item; |
| 371 | struct commit_list *parents = ret->parents; |
| 372 | struct commit_list *old = *list; |
| 373 | |
| 374 | *list = (*list)->next; |
| 375 | free(old); |
| 376 | |
| 377 | while (parents) { |
Linus Torvalds | 4056c09 | 2005-04-23 19:21:28 -0700 | [diff] [blame] | 378 | struct commit *commit = parents->item; |
Martin Koegler | dec38c8 | 2008-02-18 21:48:03 +0100 | [diff] [blame] | 379 | if (!parse_commit(commit) && !(commit->object.flags & mark)) { |
Daniel Barkalow | 58e28af | 2005-04-23 20:29:22 -0700 | [diff] [blame] | 380 | commit->object.flags |= mark; |
Linus Torvalds | f755494 | 2005-07-06 09:31:17 -0700 | [diff] [blame] | 381 | insert_by_date(commit, list); |
Linus Torvalds | 4056c09 | 2005-04-23 19:21:28 -0700 | [diff] [blame] | 382 | } |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 383 | parents = parents->next; |
| 384 | } |
| 385 | return ret; |
| 386 | } |
Linus Torvalds | e3bc7a3 | 2005-06-01 08:34:23 -0700 | [diff] [blame] | 387 | |
Junio C Hamano | f8f9c73 | 2006-01-07 18:52:42 -0800 | [diff] [blame] | 388 | void clear_commit_marks(struct commit *commit, unsigned int mark) |
| 389 | { |
Johannes Schindelin | 60fcc2e | 2007-10-10 23:14:35 +0100 | [diff] [blame] | 390 | while (commit) { |
| 391 | struct commit_list *parents; |
Junio C Hamano | f8f9c73 | 2006-01-07 18:52:42 -0800 | [diff] [blame] | 392 | |
Johannes Schindelin | 60fcc2e | 2007-10-10 23:14:35 +0100 | [diff] [blame] | 393 | if (!(mark & commit->object.flags)) |
| 394 | return; |
Junio C Hamano | 58ecf5c | 2006-07-04 17:45:22 -0700 | [diff] [blame] | 395 | |
Johannes Schindelin | 60fcc2e | 2007-10-10 23:14:35 +0100 | [diff] [blame] | 396 | commit->object.flags &= ~mark; |
| 397 | |
| 398 | parents = commit->parents; |
| 399 | if (!parents) |
| 400 | return; |
| 401 | |
| 402 | while ((parents = parents->next)) |
| 403 | clear_commit_marks(parents->item, mark); |
| 404 | |
| 405 | commit = commit->parents->item; |
Junio C Hamano | f8f9c73 | 2006-01-07 18:52:42 -0800 | [diff] [blame] | 406 | } |
| 407 | } |
| 408 | |
jon@blackcubes.dyndns.org | a3437b8 | 2005-06-06 15:39:40 +0000 | [diff] [blame] | 409 | struct commit *pop_commit(struct commit_list **stack) |
| 410 | { |
| 411 | struct commit_list *top = *stack; |
| 412 | struct commit *item = top ? top->item : NULL; |
| 413 | |
| 414 | if (top) { |
| 415 | *stack = top->next; |
| 416 | free(top); |
| 417 | } |
| 418 | return item; |
| 419 | } |
| 420 | |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 421 | /* |
| 422 | * Performs an in-place topological sort on the list supplied. |
| 423 | */ |
Junio C Hamano | 4c8725f | 2006-02-15 22:05:33 -0800 | [diff] [blame] | 424 | void sort_in_topological_order(struct commit_list ** list, int lifo) |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 425 | { |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 426 | struct commit_list *next, *orig = *list; |
| 427 | struct commit_list *work, **insert; |
| 428 | struct commit_list **pptr; |
Fredrik Kuivinen | 6b6dcfc | 2006-03-10 10:21:37 +0100 | [diff] [blame] | 429 | |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 430 | if (!orig) |
Eric Wong | 7d6fb37 | 2005-12-24 04:12:43 -0800 | [diff] [blame] | 431 | return; |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 432 | *list = NULL; |
| 433 | |
| 434 | /* Mark them and clear the indegree */ |
| 435 | for (next = orig; next; next = next->next) { |
| 436 | struct commit *commit = next->item; |
| 437 | commit->object.flags |= TOPOSORT; |
| 438 | commit->indegree = 0; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 439 | } |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 440 | |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 441 | /* update the indegree */ |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 442 | for (next = orig; next; next = next->next) { |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 443 | struct commit_list * parents = next->item->parents; |
| 444 | while (parents) { |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 445 | struct commit *parent = parents->item; |
Fredrik Kuivinen | 6b6dcfc | 2006-03-10 10:21:37 +0100 | [diff] [blame] | 446 | |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 447 | if (parent->object.flags & TOPOSORT) |
| 448 | parent->indegree++; |
| 449 | parents = parents->next; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 450 | } |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 451 | } |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 452 | |
Junio C Hamano | a6080a0 | 2007-06-07 00:04:01 -0700 | [diff] [blame] | 453 | /* |
Pierre Habouzit | 674d172 | 2007-09-10 12:35:06 +0200 | [diff] [blame] | 454 | * find the tips |
| 455 | * |
| 456 | * tips are nodes not reachable from any other node in the list |
| 457 | * |
| 458 | * the tips serve as a starting set for the work queue. |
| 459 | */ |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 460 | work = NULL; |
Linus Torvalds | 2ed0288 | 2005-11-14 10:01:26 -0800 | [diff] [blame] | 461 | insert = &work; |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 462 | for (next = orig; next; next = next->next) { |
| 463 | struct commit *commit = next->item; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 464 | |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 465 | if (!commit->indegree) |
| 466 | insert = &commit_list_insert(commit, insert)->next; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 467 | } |
Junio C Hamano | 4c8725f | 2006-02-15 22:05:33 -0800 | [diff] [blame] | 468 | |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 469 | /* process the list in topological order */ |
Junio C Hamano | 4c8725f | 2006-02-15 22:05:33 -0800 | [diff] [blame] | 470 | if (!lifo) |
| 471 | sort_by_date(&work); |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 472 | |
| 473 | pptr = list; |
| 474 | *list = NULL; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 475 | while (work) { |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 476 | struct commit *commit; |
| 477 | struct commit_list *parents, *work_item; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 478 | |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 479 | work_item = work; |
| 480 | work = work_item->next; |
| 481 | work_item->next = NULL; |
Fredrik Kuivinen | 6b6dcfc | 2006-03-10 10:21:37 +0100 | [diff] [blame] | 482 | |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 483 | commit = work_item->item; |
| 484 | for (parents = commit->parents; parents ; parents = parents->next) { |
| 485 | struct commit *parent=parents->item; |
| 486 | |
| 487 | if (!(parent->object.flags & TOPOSORT)) |
| 488 | continue; |
| 489 | |
| 490 | /* |
| 491 | * parents are only enqueued for emission |
| 492 | * when all their children have been emitted thereby |
| 493 | * guaranteeing topological order. |
| 494 | */ |
| 495 | if (!--parent->indegree) { |
| 496 | if (!lifo) |
| 497 | insert_by_date(parent, &work); |
| 498 | else |
| 499 | commit_list_insert(parent, &work); |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 500 | } |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 501 | } |
| 502 | /* |
Pierre Habouzit | 674d172 | 2007-09-10 12:35:06 +0200 | [diff] [blame] | 503 | * work_item is a commit all of whose children |
| 504 | * have already been emitted. we can emit it now. |
| 505 | */ |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 506 | commit->object.flags &= ~TOPOSORT; |
| 507 | *pptr = work_item; |
| 508 | pptr = &work_item->next; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 509 | } |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 510 | } |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 511 | |
Junio C Hamano | 1295228 | 2007-01-08 23:10:49 -0800 | [diff] [blame] | 512 | /* merge-base stuff */ |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 513 | |
Junio C Hamano | 577ed5c | 2006-10-22 17:32:47 -0700 | [diff] [blame] | 514 | /* bits #0..15 in revision.h */ |
| 515 | #define PARENT1 (1u<<16) |
| 516 | #define PARENT2 (1u<<17) |
| 517 | #define STALE (1u<<18) |
| 518 | #define RESULT (1u<<19) |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 519 | |
Junio C Hamano | 1295228 | 2007-01-08 23:10:49 -0800 | [diff] [blame] | 520 | static const unsigned all_flags = (PARENT1 | PARENT2 | STALE | RESULT); |
| 521 | |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 522 | static struct commit *interesting(struct commit_list *list) |
| 523 | { |
| 524 | while (list) { |
| 525 | struct commit *commit = list->item; |
| 526 | list = list->next; |
Junio C Hamano | 542ccef | 2006-07-02 11:34:17 -0700 | [diff] [blame] | 527 | if (commit->object.flags & STALE) |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 528 | continue; |
| 529 | return commit; |
| 530 | } |
| 531 | return NULL; |
| 532 | } |
| 533 | |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 534 | static struct commit_list *merge_bases(struct commit *one, struct commit *two) |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 535 | { |
| 536 | struct commit_list *list = NULL; |
| 537 | struct commit_list *result = NULL; |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 538 | |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 539 | if (one == two) |
| 540 | /* We do not mark this even with RESULT so we do not |
| 541 | * have to clean it up. |
| 542 | */ |
| 543 | return commit_list_insert(one, &result); |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 544 | |
Martin Koegler | 172947e | 2008-02-18 21:47:57 +0100 | [diff] [blame] | 545 | if (parse_commit(one)) |
| 546 | return NULL; |
| 547 | if (parse_commit(two)) |
| 548 | return NULL; |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 549 | |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 550 | one->object.flags |= PARENT1; |
| 551 | two->object.flags |= PARENT2; |
| 552 | insert_by_date(one, &list); |
| 553 | insert_by_date(two, &list); |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 554 | |
| 555 | while (interesting(list)) { |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 556 | struct commit *commit; |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 557 | struct commit_list *parents; |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 558 | struct commit_list *n; |
| 559 | int flags; |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 560 | |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 561 | commit = list->item; |
| 562 | n = list->next; |
| 563 | free(list); |
| 564 | list = n; |
| 565 | |
| 566 | flags = commit->object.flags & (PARENT1 | PARENT2 | STALE); |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 567 | if (flags == (PARENT1 | PARENT2)) { |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 568 | if (!(commit->object.flags & RESULT)) { |
| 569 | commit->object.flags |= RESULT; |
| 570 | insert_by_date(commit, &result); |
| 571 | } |
Junio C Hamano | 542ccef | 2006-07-02 11:34:17 -0700 | [diff] [blame] | 572 | /* Mark parents of a found merge stale */ |
| 573 | flags |= STALE; |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 574 | } |
| 575 | parents = commit->parents; |
| 576 | while (parents) { |
| 577 | struct commit *p = parents->item; |
| 578 | parents = parents->next; |
| 579 | if ((p->object.flags & flags) == flags) |
| 580 | continue; |
Martin Koegler | 172947e | 2008-02-18 21:47:57 +0100 | [diff] [blame] | 581 | if (parse_commit(p)) |
| 582 | return NULL; |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 583 | p->object.flags |= flags; |
| 584 | insert_by_date(p, &list); |
| 585 | } |
| 586 | } |
| 587 | |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 588 | /* Clean up the result to remove stale ones */ |
Junio C Hamano | 1295228 | 2007-01-08 23:10:49 -0800 | [diff] [blame] | 589 | free_commit_list(list); |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 590 | list = result; result = NULL; |
| 591 | while (list) { |
| 592 | struct commit_list *n = list->next; |
| 593 | if (!(list->item->object.flags & STALE)) |
| 594 | insert_by_date(list->item, &result); |
| 595 | free(list); |
| 596 | list = n; |
| 597 | } |
| 598 | return result; |
| 599 | } |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 600 | |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 601 | struct commit_list *get_merge_bases(struct commit *one, |
Pierre Habouzit | 674d172 | 2007-09-10 12:35:06 +0200 | [diff] [blame] | 602 | struct commit *two, int cleanup) |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 603 | { |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 604 | struct commit_list *list; |
| 605 | struct commit **rslt; |
| 606 | struct commit_list *result; |
| 607 | int cnt, i, j; |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 608 | |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 609 | result = merge_bases(one, two); |
| 610 | if (one == two) |
| 611 | return result; |
| 612 | if (!result || !result->next) { |
| 613 | if (cleanup) { |
| 614 | clear_commit_marks(one, all_flags); |
| 615 | clear_commit_marks(two, all_flags); |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 616 | } |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 617 | return result; |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 618 | } |
| 619 | |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 620 | /* There are more than one */ |
| 621 | cnt = 0; |
| 622 | list = result; |
| 623 | while (list) { |
| 624 | list = list->next; |
| 625 | cnt++; |
| 626 | } |
| 627 | rslt = xcalloc(cnt, sizeof(*rslt)); |
| 628 | for (list = result, i = 0; list; list = list->next) |
| 629 | rslt[i++] = list->item; |
| 630 | free_commit_list(result); |
| 631 | |
| 632 | clear_commit_marks(one, all_flags); |
| 633 | clear_commit_marks(two, all_flags); |
| 634 | for (i = 0; i < cnt - 1; i++) { |
| 635 | for (j = i+1; j < cnt; j++) { |
| 636 | if (!rslt[i] || !rslt[j]) |
| 637 | continue; |
| 638 | result = merge_bases(rslt[i], rslt[j]); |
| 639 | clear_commit_marks(rslt[i], all_flags); |
| 640 | clear_commit_marks(rslt[j], all_flags); |
| 641 | for (list = result; list; list = list->next) { |
| 642 | if (rslt[i] == list->item) |
| 643 | rslt[i] = NULL; |
| 644 | if (rslt[j] == list->item) |
| 645 | rslt[j] = NULL; |
| 646 | } |
| 647 | } |
Junio C Hamano | 58ecf5c | 2006-07-04 17:45:22 -0700 | [diff] [blame] | 648 | } |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 649 | |
Junio C Hamano | f324943 | 2006-07-04 18:46:42 -0700 | [diff] [blame] | 650 | /* Surviving ones in rslt[] are the independent results */ |
| 651 | result = NULL; |
| 652 | for (i = 0; i < cnt; i++) { |
| 653 | if (rslt[i]) |
| 654 | insert_by_date(rslt[i], &result); |
| 655 | } |
| 656 | free(rslt); |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 657 | return result; |
| 658 | } |
Junio C Hamano | 2ecd2bb | 2006-12-19 00:14:04 -0800 | [diff] [blame] | 659 | |
Junio C Hamano | 03840fc | 2007-01-08 23:22:31 -0800 | [diff] [blame] | 660 | int in_merge_bases(struct commit *commit, struct commit **reference, int num) |
Junio C Hamano | 2ecd2bb | 2006-12-19 00:14:04 -0800 | [diff] [blame] | 661 | { |
| 662 | struct commit_list *bases, *b; |
| 663 | int ret = 0; |
| 664 | |
Junio C Hamano | 03840fc | 2007-01-08 23:22:31 -0800 | [diff] [blame] | 665 | if (num == 1) |
| 666 | bases = get_merge_bases(commit, *reference, 1); |
| 667 | else |
| 668 | die("not yet"); |
Junio C Hamano | 2ecd2bb | 2006-12-19 00:14:04 -0800 | [diff] [blame] | 669 | for (b = bases; b; b = b->next) { |
Junio C Hamano | 03840fc | 2007-01-08 23:22:31 -0800 | [diff] [blame] | 670 | if (!hashcmp(commit->object.sha1, b->item->object.sha1)) { |
Junio C Hamano | 2ecd2bb | 2006-12-19 00:14:04 -0800 | [diff] [blame] | 671 | ret = 1; |
| 672 | break; |
| 673 | } |
| 674 | } |
| 675 | |
| 676 | free_commit_list(bases); |
| 677 | return ret; |
| 678 | } |