commit.c

   1 #include <ctype.h>
   2 #include "tag.h"
   3 #include "commit.h"
   4 #include "cache.h"
   5
   6 const char *commit_type = "commit";
   7
   8 static struct commit *check_commit(struct object *obj, const unsigned char *sha1)
   9 {
  10         if (obj->type != commit_type) {
  11                 error("Object %s is a %s, not a commit",
  12                       sha1_to_hex(sha1), obj->type);
  13                 return NULL;
  14         }
  15         return (struct commit *) obj;
  16 }
  17
  18 struct commit *lookup_commit_reference(const unsigned char *sha1)
  19 {
  20         struct object *obj = parse_object(sha1);
  21
  22         if (!obj)
  23                 return NULL;
  24         if (obj->type == tag_type)
  25                 obj = ((struct tag *)obj)->tagged;
  26         return check_commit(obj, sha1);
  27 }
  28
  29 struct commit *lookup_commit(const unsigned char *sha1)
  30 {
  31         struct object *obj = lookup_object(sha1);
  32         if (!obj) {
  33                 struct commit *ret = xmalloc(sizeof(struct commit));
  34                 memset(ret, 0, sizeof(struct commit));
  35                 created_object(sha1, &ret->object);
  36                 ret->object.type = commit_type;
  37                 return ret;
  38         }
  39         if (!obj->type)
  40                 obj->type = commit_type;
  41         return check_commit(obj, sha1);
  42 }
  43
  44 static unsigned long parse_commit_date(const char *buf)
  45 {
  46         unsigned long date;
  47
  48         if (memcmp(buf, "author", 6))
  49                 return 0;
  50         while (*buf++ != '\n')
  51                 /* nada */;
  52         if (memcmp(buf, "committer", 9))
  53                 return 0;
  54         while (*buf++ != '>')
  55                 /* nada */;
  56         date = strtoul(buf, NULL, 10);
  57         if (date == ULONG_MAX)
  58                 date = 0;
  59         return date;
  60 }
  61
  62 int parse_commit_buffer(struct commit *item, void *buffer, unsigned long size)
  63 {
  64         void *bufptr = buffer;
  65         unsigned char parent[20];
  66
  67         if (item->object.parsed)
  68                 return 0;
  69         item->object.parsed = 1;
  70         get_sha1_hex(bufptr + 5, parent);
  71         item->tree = lookup_tree(parent);
  72         if (item->tree)
  73                 add_ref(&item->object, &item->tree->object);
  74         bufptr += 46; /* "tree " + "hex sha1" + "\n" */
  75         while (!memcmp(bufptr, "parent ", 7) &&
  76                !get_sha1_hex(bufptr + 7, parent)) {
  77                 struct commit *new_parent = lookup_commit(parent);
  78                 if (new_parent) {
  79                         commit_list_insert(new_parent, &item->parents);
  80                         add_ref(&item->object, &new_parent->object);
  81                 }
  82                 bufptr += 48;
  83         }
  84         item->date = parse_commit_date(bufptr);
  85         return 0;
  86 }
  87
  88 int parse_commit(struct commit *item)
  89 {
  90         char type[20];
  91         void *buffer;
  92         unsigned long size;
  93         int ret;
  94
  95         if (item->object.parsed)
  96                 return 0;
  97         buffer = read_sha1_file(item->object.sha1, type, &size);
  98         if (!buffer)
  99                 return error("Could not read %s",
 100                              sha1_to_hex(item->object.sha1));
 101         if (strcmp(type, commit_type)) {
 102                 free(buffer);
 103                 return error("Object %s not a commit",
 104                              sha1_to_hex(item->object.sha1));
 105         }
 106         ret = parse_commit_buffer(item, buffer, size);
 107         if (!ret) {
 108                 item->buffer = buffer;
 109                 return 0;
 110         }
 111         free(buffer);
 112         return ret;
 113 }
 114
 115 struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p)
 116 {
 117         struct commit_list *new_list = xmalloc(sizeof(struct commit_list));
 118         new_list->item = item;
 119         new_list->next = *list_p;
 120         *list_p = new_list;
 121         return new_list;
 122 }
 123
 124 void free_commit_list(struct commit_list *list)
 125 {
 126         while (list) {
 127                 struct commit_list *temp = list;
 128                 list = temp->next;
 129                 free(temp);
 130         }
 131 }
 132
 133 void insert_by_date(struct commit_list **list, struct commit *item)
 134 {
 135         struct commit_list **pp = list;
 136         struct commit_list *p;
 137         while ((p = *pp) != NULL) {
 138                 if (p->item->date < item->date) {
 139                         break;
 140                 }
 141                 pp = &p->next;
 142         }
 143         commit_list_insert(item, pp);
 144 }
 145
 146
 147 void sort_by_date(struct commit_list **list)
 148 {
 149         struct commit_list *ret = NULL;
 150         while (*list) {
 151                 insert_by_date(&ret, (*list)->item);
 152                 *list = (*list)->next;
 153         }
 154         *list = ret;
 155 }
 156
 157 struct commit *pop_most_recent_commit(struct commit_list **list,
 158                                       unsigned int mark)
 159 {
 160         struct commit *ret = (*list)->item;
 161         struct commit_list *parents = ret->parents;
 162         struct commit_list *old = *list;
 163
 164         *list = (*list)->next;
 165         free(old);
 166
 167         while (parents) {
 168                 struct commit *commit = parents->item;
 169                 parse_commit(commit);
 170                 if (!(commit->object.flags & mark)) {
 171                         commit->object.flags |= mark;
 172                         insert_by_date(list, commit);
 173                 }
 174                 parents = parents->next;
 175         }
 176         return ret;
 177 }
 178
 179 /*
 180  * Generic support for pretty-printing the header
 181  */
 182 static int get_one_line(const char *msg, unsigned long len)
 183 {
 184         int ret = 0;
 185
 186         while (len--) {
 187                 char c = *msg++;
 188                 ret++;
 189                 if (c == '\n')
 190                         break;
 191                 if (!c)
 192                         return 0;
 193         }
 194         return ret;
 195 }
 196
 197 static int add_author_info(enum cmit_fmt fmt, char *buf, const char *line, int len)
 198 {
 199         char *date;
 200         unsigned int namelen;
 201         unsigned long time;
 202         int tz, ret;
 203
 204         line += strlen("author ");
 205         date = strchr(line, '>');
 206         if (!date)
 207                 return 0;
 208         namelen = ++date - line;
 209         time = strtoul(date, &date, 10);
 210         tz = strtol(date, NULL, 10);
 211
 212         ret = sprintf(buf, "Author: %.*s\n", namelen, line);
 213         if (fmt == CMIT_FMT_MEDIUM)
 214                 ret += sprintf(buf + ret, "Date:   %s\n", show_date(time, tz));
 215         return ret;
 216 }
 217
 218 static int is_empty_line(const char *line, int len)
 219 {
 220         while (len && isspace(line[len-1]))
 221                 len--;
 222         return !len;
 223 }
 224
 225 unsigned long pretty_print_commit(enum cmit_fmt fmt, const char *msg, unsigned long len, char *buf, unsigned long space)
 226 {
 227         int hdr = 1, body = 0;
 228         unsigned long offset = 0;
 229
 230         for (;;) {
 231                 const char *line = msg;
 232                 int linelen = get_one_line(msg, len);
 233
 234                 if (!linelen)
 235                         break;
 236
 237                 /*
 238                  * We want some slop for indentation and a possible
 239                  * final "...". Thus the "+ 20".
 240                  */
 241                 if (offset + linelen + 20 > space) {
 242                         memcpy(buf + offset, "    ...\n", 8);
 243                         offset += 8;
 244                         break;
 245                 }
 246
 247                 msg += linelen;
 248                 len -= linelen;
 249                 if (hdr) {
 250                         if (linelen == 1) {
 251                                 hdr = 0;
 252                                 buf[offset++] = '\n';
 253                                 continue;
 254                         }
 255                         if (fmt == CMIT_FMT_RAW) {
 256                                 memcpy(buf + offset, line, linelen);
 257                                 offset += linelen;
 258                                 continue;
 259                         }
 260                         if (!memcmp(line, "author ", 7))
 261                                 offset += add_author_info(fmt, buf + offset, line, linelen);
 262                         continue;
 263                 }
 264
 265                 if (is_empty_line(line, linelen)) {
 266                         if (!body)
 267                                 continue;
 268                         if (fmt == CMIT_FMT_SHORT)
 269                                 break;
 270                 } else {
 271                         body = 1;
 272                 }
 273                 memset(buf + offset, ' ', 4);
 274                 memcpy(buf + offset + 4, line, linelen);
 275                 offset += linelen + 4;
 276         }
 277         /* Make sure there is an EOLN */
 278         if (buf[offset - 1] != '\n')
 279                 buf[offset++] = '\n';
 280         buf[offset] = '\0';
 281         return offset;
 282 }
 283
 284 struct commit *pop_commit(struct commit_list **stack)
 285 {
 286         struct commit_list *top = *stack;
 287         struct commit *item = top ? top->item : NULL;
 288
 289         if (top) {
 290                 *stack = top->next;
 291                 free(top);
 292         }
 293         return item;
 294 }
 295
 296 int count_parents(struct commit * commit)
 297 {
 298         int count = 0;
 299         struct commit_list * parents = commit->parents;
 300         for (count=0;parents; parents=parents->next,count++)
 301           ;
 302         return count;
 303 }
 304