Merge branch 'master' into jc/combine
[git] / commit.c
1 #include "cache.h"
2 #include "tag.h"
3 #include "commit.h"
4
5 int save_commit_buffer = 1;
6
7 struct sort_node
8 {
9         /*
10          * the number of children of the associated commit
11          * that also occur in the list being sorted.
12          */
13         unsigned int indegree;
14
15         /*
16          * reference to original list item that we will re-use
17          * on output.
18          */
19         struct commit_list * list_item;
20
21 };
22
23 const char *commit_type = "commit";
24
25 enum cmit_fmt get_commit_format(const char *arg)
26 {
27         if (!*arg)
28                 return CMIT_FMT_DEFAULT;
29         if (!strcmp(arg, "=raw"))
30                 return CMIT_FMT_RAW;
31         if (!strcmp(arg, "=medium"))
32                 return CMIT_FMT_MEDIUM;
33         if (!strcmp(arg, "=short"))
34                 return CMIT_FMT_SHORT;
35         if (!strcmp(arg, "=full"))
36                 return CMIT_FMT_FULL;
37         if (!strcmp(arg, "=fuller"))
38                 return CMIT_FMT_FULLER;
39         if (!strcmp(arg, "=oneline"))
40                 return CMIT_FMT_ONELINE;
41         die("invalid --pretty format");
42 }
43
44 static struct commit *check_commit(struct object *obj,
45                                    const unsigned char *sha1,
46                                    int quiet)
47 {
48         if (obj->type != commit_type) {
49                 if (!quiet)
50                         error("Object %s is a %s, not a commit",
51                               sha1_to_hex(sha1), obj->type);
52                 return NULL;
53         }
54         return (struct commit *) obj;
55 }
56
57 struct commit *lookup_commit_reference_gently(const unsigned char *sha1,
58                                               int quiet)
59 {
60         struct object *obj = deref_tag(parse_object(sha1), NULL, 0);
61
62         if (!obj)
63                 return NULL;
64         return check_commit(obj, sha1, quiet);
65 }
66
67 struct commit *lookup_commit_reference(const unsigned char *sha1)
68 {
69         return lookup_commit_reference_gently(sha1, 0);
70 }
71
72 struct commit *lookup_commit(const unsigned char *sha1)
73 {
74         struct object *obj = lookup_object(sha1);
75         if (!obj) {
76                 struct commit *ret = xcalloc(1, sizeof(struct commit));
77                 created_object(sha1, &ret->object);
78                 ret->object.type = commit_type;
79                 return ret;
80         }
81         if (!obj->type)
82                 obj->type = commit_type;
83         return check_commit(obj, sha1, 0);
84 }
85
86 static unsigned long parse_commit_date(const char *buf)
87 {
88         unsigned long date;
89
90         if (memcmp(buf, "author", 6))
91                 return 0;
92         while (*buf++ != '\n')
93                 /* nada */;
94         if (memcmp(buf, "committer", 9))
95                 return 0;
96         while (*buf++ != '>')
97                 /* nada */;
98         date = strtoul(buf, NULL, 10);
99         if (date == ULONG_MAX)
100                 date = 0;
101         return date;
102 }
103
104 static struct commit_graft **commit_graft;
105 static int commit_graft_alloc, commit_graft_nr;
106
107 static int commit_graft_pos(const unsigned char *sha1)
108 {
109         int lo, hi;
110         lo = 0;
111         hi = commit_graft_nr;
112         while (lo < hi) {
113                 int mi = (lo + hi) / 2;
114                 struct commit_graft *graft = commit_graft[mi];
115                 int cmp = memcmp(sha1, graft->sha1, 20);
116                 if (!cmp)
117                         return mi;
118                 if (cmp < 0)
119                         hi = mi;
120                 else
121                         lo = mi + 1;
122         }
123         return -lo - 1;
124 }
125
126 int register_commit_graft(struct commit_graft *graft, int ignore_dups)
127 {
128         int pos = commit_graft_pos(graft->sha1);
129         
130         if (0 <= pos) {
131                 if (ignore_dups)
132                         free(graft);
133                 else {
134                         free(commit_graft[pos]);
135                         commit_graft[pos] = graft;
136                 }
137                 return 1;
138         }
139         pos = -pos - 1;
140         if (commit_graft_alloc <= ++commit_graft_nr) {
141                 commit_graft_alloc = alloc_nr(commit_graft_alloc);
142                 commit_graft = xrealloc(commit_graft,
143                                         sizeof(*commit_graft) *
144                                         commit_graft_alloc);
145         }
146         if (pos < commit_graft_nr)
147                 memmove(commit_graft + pos + 1,
148                         commit_graft + pos,
149                         (commit_graft_nr - pos - 1) *
150                         sizeof(*commit_graft));
151         commit_graft[pos] = graft;
152         return 0;
153 }
154
155 struct commit_graft *read_graft_line(char *buf, int len)
156 {
157         /* The format is just "Commit Parent1 Parent2 ...\n" */
158         int i;
159         struct commit_graft *graft = NULL;
160
161         if (buf[len-1] == '\n')
162                 buf[--len] = 0;
163         if (buf[0] == '#')
164                 return 0;
165         if ((len + 1) % 41) {
166         bad_graft_data:
167                 error("bad graft data: %s", buf);
168                 free(graft);
169                 return NULL;
170         }
171         i = (len + 1) / 41 - 1;
172         graft = xmalloc(sizeof(*graft) + 20 * i);
173         graft->nr_parent = i;
174         if (get_sha1_hex(buf, graft->sha1))
175                 goto bad_graft_data;
176         for (i = 40; i < len; i += 41) {
177                 if (buf[i] != ' ')
178                         goto bad_graft_data;
179                 if (get_sha1_hex(buf + i + 1, graft->parent[i/41]))
180                         goto bad_graft_data;
181         }
182         return graft;
183 }
184
185 int read_graft_file(const char *graft_file)
186 {
187         FILE *fp = fopen(graft_file, "r");
188         char buf[1024];
189         if (!fp)
190                 return -1;
191         while (fgets(buf, sizeof(buf), fp)) {
192                 /* The format is just "Commit Parent1 Parent2 ...\n" */
193                 int len = strlen(buf);
194                 struct commit_graft *graft = read_graft_line(buf, len);
195                 if (register_commit_graft(graft, 1))
196                         error("duplicate graft data: %s", buf);
197         }
198         fclose(fp);
199         return 0;
200 }
201
202 static void prepare_commit_graft(void)
203 {
204         static int commit_graft_prepared;
205         char *graft_file;
206
207         if (commit_graft_prepared)
208                 return;
209         graft_file = get_graft_file();
210         read_graft_file(graft_file);
211         commit_graft_prepared = 1;
212 }
213
214 static struct commit_graft *lookup_commit_graft(const unsigned char *sha1)
215 {
216         int pos;
217         prepare_commit_graft();
218         pos = commit_graft_pos(sha1);
219         if (pos < 0)
220                 return NULL;
221         return commit_graft[pos];
222 }
223
224 int parse_commit_buffer(struct commit *item, void *buffer, unsigned long size)
225 {
226         char *bufptr = buffer;
227         unsigned char parent[20];
228         struct commit_list **pptr;
229         struct commit_graft *graft;
230         unsigned n_refs = 0;
231
232         if (item->object.parsed)
233                 return 0;
234         item->object.parsed = 1;
235         if (memcmp(bufptr, "tree ", 5))
236                 return error("bogus commit object %s", sha1_to_hex(item->object.sha1));
237         if (get_sha1_hex(bufptr + 5, parent) < 0)
238                 return error("bad tree pointer in commit %s",
239                              sha1_to_hex(item->object.sha1));
240         item->tree = lookup_tree(parent);
241         if (item->tree)
242                 n_refs++;
243         bufptr += 46; /* "tree " + "hex sha1" + "\n" */
244         pptr = &item->parents;
245
246         graft = lookup_commit_graft(item->object.sha1);
247         while (!memcmp(bufptr, "parent ", 7)) {
248                 struct commit *new_parent;
249
250                 if (get_sha1_hex(bufptr + 7, parent) || bufptr[47] != '\n')
251                         return error("bad parents in commit %s", sha1_to_hex(item->object.sha1));
252                 bufptr += 48;
253                 if (graft)
254                         continue;
255                 new_parent = lookup_commit(parent);
256                 if (new_parent) {
257                         pptr = &commit_list_insert(new_parent, pptr)->next;
258                         n_refs++;
259                 }
260         }
261         if (graft) {
262                 int i;
263                 struct commit *new_parent;
264                 for (i = 0; i < graft->nr_parent; i++) {
265                         new_parent = lookup_commit(graft->parent[i]);
266                         if (!new_parent)
267                                 continue;
268                         pptr = &commit_list_insert(new_parent, pptr)->next;
269                         n_refs++;
270                 }
271         }
272         item->date = parse_commit_date(bufptr);
273
274         if (track_object_refs) {
275                 unsigned i = 0;
276                 struct commit_list *p;
277                 struct object_refs *refs = alloc_object_refs(n_refs);
278                 if (item->tree)
279                         refs->ref[i++] = &item->tree->object;
280                 for (p = item->parents; p; p = p->next)
281                         refs->ref[i++] = &p->item->object;
282                 set_object_refs(&item->object, refs);
283         }
284
285         return 0;
286 }
287
288 int parse_commit(struct commit *item)
289 {
290         char type[20];
291         void *buffer;
292         unsigned long size;
293         int ret;
294
295         if (item->object.parsed)
296                 return 0;
297         buffer = read_sha1_file(item->object.sha1, type, &size);
298         if (!buffer)
299                 return error("Could not read %s",
300                              sha1_to_hex(item->object.sha1));
301         if (strcmp(type, commit_type)) {
302                 free(buffer);
303                 return error("Object %s not a commit",
304                              sha1_to_hex(item->object.sha1));
305         }
306         ret = parse_commit_buffer(item, buffer, size);
307         if (save_commit_buffer && !ret) {
308                 item->buffer = buffer;
309                 return 0;
310         }
311         free(buffer);
312         return ret;
313 }
314
315 struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p)
316 {
317         struct commit_list *new_list = xmalloc(sizeof(struct commit_list));
318         new_list->item = item;
319         new_list->next = *list_p;
320         *list_p = new_list;
321         return new_list;
322 }
323
324 void free_commit_list(struct commit_list *list)
325 {
326         while (list) {
327                 struct commit_list *temp = list;
328                 list = temp->next;
329                 free(temp);
330         }
331 }
332
333 struct commit_list * insert_by_date(struct commit *item, struct commit_list **list)
334 {
335         struct commit_list **pp = list;
336         struct commit_list *p;
337         while ((p = *pp) != NULL) {
338                 if (p->item->date < item->date) {
339                         break;
340                 }
341                 pp = &p->next;
342         }
343         return commit_list_insert(item, pp);
344 }
345
346         
347 void sort_by_date(struct commit_list **list)
348 {
349         struct commit_list *ret = NULL;
350         while (*list) {
351                 insert_by_date((*list)->item, &ret);
352                 *list = (*list)->next;
353         }
354         *list = ret;
355 }
356
357 struct commit *pop_most_recent_commit(struct commit_list **list,
358                                       unsigned int mark)
359 {
360         struct commit *ret = (*list)->item;
361         struct commit_list *parents = ret->parents;
362         struct commit_list *old = *list;
363
364         *list = (*list)->next;
365         free(old);
366
367         while (parents) {
368                 struct commit *commit = parents->item;
369                 parse_commit(commit);
370                 if (!(commit->object.flags & mark)) {
371                         commit->object.flags |= mark;
372                         insert_by_date(commit, list);
373                 }
374                 parents = parents->next;
375         }
376         return ret;
377 }
378
379 void clear_commit_marks(struct commit *commit, unsigned int mark)
380 {
381         struct commit_list *parents;
382
383         parents = commit->parents;
384         commit->object.flags &= ~mark;
385         while (parents) {
386                 struct commit *parent = parents->item;
387                 if (parent && parent->object.parsed &&
388                     (parent->object.flags & mark))
389                         clear_commit_marks(parent, mark);
390                 parents = parents->next;
391         }
392 }
393
394 /*
395  * Generic support for pretty-printing the header
396  */
397 static int get_one_line(const char *msg, unsigned long len)
398 {
399         int ret = 0;
400
401         while (len--) {
402                 char c = *msg++;
403                 if (!c)
404                         break;
405                 ret++;
406                 if (c == '\n')
407                         break;
408         }
409         return ret;
410 }
411
412 static int add_user_info(const char *what, enum cmit_fmt fmt, char *buf, const char *line)
413 {
414         char *date;
415         int namelen;
416         unsigned long time;
417         int tz, ret;
418         const char *filler = "    ";
419
420         if (fmt == CMIT_FMT_ONELINE)
421                 return 0;
422         date = strchr(line, '>');
423         if (!date)
424                 return 0;
425         namelen = ++date - line;
426         time = strtoul(date, &date, 10);
427         tz = strtol(date, NULL, 10);
428
429         ret = sprintf(buf, "%s: %.*s%.*s\n", what,
430                       (fmt == CMIT_FMT_FULLER) ? 4 : 0,
431                       filler, namelen, line);
432         switch (fmt) {
433         case CMIT_FMT_MEDIUM:
434                 ret += sprintf(buf + ret, "Date:   %s\n", show_date(time, tz));
435                 break;
436         case CMIT_FMT_FULLER:
437                 ret += sprintf(buf + ret, "%sDate: %s\n", what, show_date(time, tz));
438                 break;
439         default:
440                 /* notin' */
441                 break;
442         }
443         return ret;
444 }
445
446 static int is_empty_line(const char *line, int len)
447 {
448         while (len && isspace(line[len-1]))
449                 len--;
450         return !len;
451 }
452
453 static int add_merge_info(enum cmit_fmt fmt, char *buf, const struct commit *commit, int abbrev)
454 {
455         struct commit_list *parent = commit->parents;
456         int offset;
457
458         if ((fmt == CMIT_FMT_ONELINE) || !parent || !parent->next)
459                 return 0;
460
461         offset = sprintf(buf, "Merge:");
462
463         while (parent) {
464                 struct commit *p = parent->item;
465                 const char *hex = abbrev
466                         ? find_unique_abbrev(p->object.sha1, abbrev)
467                         : sha1_to_hex(p->object.sha1);
468                 char *dots = (abbrev && strlen(hex) != 40) ? "..." : "";
469                 parent = parent->next;
470
471                 offset += sprintf(buf + offset, " %s%s", hex, dots);
472         }
473         buf[offset++] = '\n';
474         return offset;
475 }
476
477 unsigned long pretty_print_commit(enum cmit_fmt fmt, const struct commit *commit, unsigned long len, char *buf, unsigned long space, int abbrev)
478 {
479         int hdr = 1, body = 0;
480         unsigned long offset = 0;
481         int indent = (fmt == CMIT_FMT_ONELINE) ? 0 : 4;
482         int parents_shown = 0;
483         const char *msg = commit->buffer;
484
485         for (;;) {
486                 const char *line = msg;
487                 int linelen = get_one_line(msg, len);
488
489                 if (!linelen)
490                         break;
491
492                 /*
493                  * We want some slop for indentation and a possible
494                  * final "...". Thus the "+ 20".
495                  */
496                 if (offset + linelen + 20 > space) {
497                         memcpy(buf + offset, "    ...\n", 8);
498                         offset += 8;
499                         break;
500                 }
501
502                 msg += linelen;
503                 len -= linelen;
504                 if (hdr) {
505                         if (linelen == 1) {
506                                 hdr = 0;
507                                 if (fmt != CMIT_FMT_ONELINE)
508                                         buf[offset++] = '\n';
509                                 continue;
510                         }
511                         if (fmt == CMIT_FMT_RAW) {
512                                 memcpy(buf + offset, line, linelen);
513                                 offset += linelen;
514                                 continue;
515                         }
516                         if (!memcmp(line, "parent ", 7)) {
517                                 if (linelen != 48)
518                                         die("bad parent line in commit");
519                                 continue;
520                         }
521
522                         if (!parents_shown) {
523                                 offset += add_merge_info(fmt, buf + offset,
524                                                          commit, abbrev);
525                                 parents_shown = 1;
526                                 continue;
527                         }
528                         /*
529                          * MEDIUM == DEFAULT shows only author with dates.
530                          * FULL shows both authors but not dates.
531                          * FULLER shows both authors and dates.
532                          */
533                         if (!memcmp(line, "author ", 7))
534                                 offset += add_user_info("Author", fmt,
535                                                         buf + offset,
536                                                         line + 7);
537                         if (!memcmp(line, "committer ", 10) &&
538                             (fmt == CMIT_FMT_FULL || fmt == CMIT_FMT_FULLER))
539                                 offset += add_user_info("Commit", fmt,
540                                                         buf + offset,
541                                                         line + 10);
542                         continue;
543                 }
544
545                 if (is_empty_line(line, linelen)) {
546                         if (!body)
547                                 continue;
548                         if (fmt == CMIT_FMT_SHORT)
549                                 break;
550                 } else {
551                         body = 1;
552                 }
553
554                 memset(buf + offset, ' ', indent);
555                 memcpy(buf + offset + indent, line, linelen);
556                 offset += linelen + indent;
557                 if (fmt == CMIT_FMT_ONELINE)
558                         break;
559         }
560         if (fmt == CMIT_FMT_ONELINE) {
561                 /* We do not want the terminating newline */
562                 if (buf[offset - 1] == '\n')
563                         offset--;
564         }
565         else {
566                 /* Make sure there is an EOLN */
567                 if (buf[offset - 1] != '\n')
568                         buf[offset++] = '\n';
569         }
570         buf[offset] = '\0';
571         return offset;
572 }
573
574 struct commit *pop_commit(struct commit_list **stack)
575 {
576         struct commit_list *top = *stack;
577         struct commit *item = top ? top->item : NULL;
578
579         if (top) {
580                 *stack = top->next;
581                 free(top);
582         }
583         return item;
584 }
585
586 int count_parents(struct commit * commit)
587 {
588         int count = 0;
589         struct commit_list * parents = commit->parents;
590         for (count=0;parents; parents=parents->next,count++)
591           ;
592         return count;
593 }
594
595 void topo_sort_default_setter(struct commit *c, void *data)
596 {
597         c->object.util = data;
598 }
599
600 void *topo_sort_default_getter(struct commit *c)
601 {
602         return c->object.util;
603 }
604
605 /*
606  * Performs an in-place topological sort on the list supplied.
607  */
608 void sort_in_topological_order(struct commit_list ** list, int lifo)
609 {
610         sort_in_topological_order_fn(list, lifo, topo_sort_default_setter,
611                                      topo_sort_default_getter);
612 }
613
614 void sort_in_topological_order_fn(struct commit_list ** list, int lifo,
615                                   topo_sort_set_fn_t setter,
616                                   topo_sort_get_fn_t getter)
617 {
618         struct commit_list * next = *list;
619         struct commit_list * work = NULL, **insert;
620         struct commit_list ** pptr = list;
621         struct sort_node * nodes;
622         struct sort_node * next_nodes;
623         int count = 0;
624
625         /* determine the size of the list */
626         while (next) {
627                 next = next->next;
628                 count++;
629         }
630         
631         if (!count)
632                 return;
633         /* allocate an array to help sort the list */
634         nodes = xcalloc(count, sizeof(*nodes));
635         /* link the list to the array */
636         next_nodes = nodes;
637         next=*list;
638         while (next) {
639                 next_nodes->list_item = next;
640                 setter(next->item, next_nodes);
641                 next_nodes++;
642                 next = next->next;
643         }
644         /* update the indegree */
645         next=*list;
646         while (next) {
647                 struct commit_list * parents = next->item->parents;
648                 while (parents) {
649                         struct commit * parent=parents->item;
650                         struct sort_node * pn = (struct sort_node *) getter(parent);
651
652                         if (pn)
653                                 pn->indegree++;
654                         parents=parents->next;
655                 }
656                 next=next->next;
657         }
658         /* 
659          * find the tips
660          *
661          * tips are nodes not reachable from any other node in the list 
662          * 
663          * the tips serve as a starting set for the work queue.
664          */
665         next=*list;
666         insert = &work;
667         while (next) {
668                 struct sort_node * node = (struct sort_node *) getter(next->item);
669
670                 if (node->indegree == 0) {
671                         insert = &commit_list_insert(next->item, insert)->next;
672                 }
673                 next=next->next;
674         }
675
676         /* process the list in topological order */
677         if (!lifo)
678                 sort_by_date(&work);
679         while (work) {
680                 struct commit * work_item = pop_commit(&work);
681                 struct sort_node * work_node = (struct sort_node *) getter(work_item);
682                 struct commit_list * parents = work_item->parents;
683
684                 while (parents) {
685                         struct commit * parent=parents->item;
686                         struct sort_node * pn = (struct sort_node *) getter(parent);
687
688                         if (pn) {
689                                 /*
690                                  * parents are only enqueued for emission 
691                                  * when all their children have been emitted thereby
692                                  * guaranteeing topological order.
693                                  */
694                                 pn->indegree--;
695                                 if (!pn->indegree) {
696                                         if (!lifo)
697                                                 insert_by_date(parent, &work);
698                                         else
699                                                 commit_list_insert(parent, &work);
700                                 }
701                         }
702                         parents=parents->next;
703                 }
704                 /*
705                  * work_item is a commit all of whose children
706                  * have already been emitted. we can emit it now.
707                  */
708                 *pptr = work_node->list_item;
709                 pptr = &(*pptr)->next;
710                 *pptr = NULL;
711                 setter(work_item, NULL);
712         }
713         free(nodes);
714 }