diff-tree.c

   1 #include "cache.h"
   2 #include "diff.h"
   3
   4 static int recursive = 0;
   5 static int line_termination = '\n';
   6 static int generate_patch = 0;
   7
   8 // What paths are we interested in?
   9 static int nr_paths = 0;
  10 static char **paths = NULL;
  11 static int *pathlens = NULL;
  12
  13 static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base);
  14
  15 static void update_tree_entry(void **bufp, unsigned long *sizep)
  16 {
  17         void *buf = *bufp;
  18         unsigned long size = *sizep;
  19         int len = strlen(buf) + 1 + 20;
  20
  21         if (size < len)
  22                 die("corrupt tree file");
  23         *bufp = buf + len;
  24         *sizep = size - len;
  25 }
  26
  27 static const unsigned char *extract(void *tree, unsigned long size, const char **pathp, unsigned int *modep)
  28 {
  29         int len = strlen(tree)+1;
  30         const unsigned char *sha1 = tree + len;
  31         const char *path = strchr(tree, ' ');
  32
  33         if (!path || size < len + 20 || sscanf(tree, "%o", modep) != 1)
  34                 die("corrupt tree file");
  35         *pathp = path+1;
  36         return sha1;
  37 }
  38
  39 static char *malloc_base(const char *base, const char *path, int pathlen)
  40 {
  41         int baselen = strlen(base);
  42         char *newbase = xmalloc(baselen + pathlen + 2);
  43         memcpy(newbase, base, baselen);
  44         memcpy(newbase + baselen, path, pathlen);
  45         memcpy(newbase + baselen + pathlen, "/", 2);
  46         return newbase;
  47 }
  48
  49 static void show_file(const char *prefix, void *tree, unsigned long size, const char *base);
  50
  51 /* A whole sub-tree went away or appeared */
  52 static void show_tree(const char *prefix, void *tree, unsigned long size, const char *base)
  53 {
  54         while (size) {
  55                 show_file(prefix, tree, size, base);
  56                 update_tree_entry(&tree, &size);
  57         }
  58 }
  59
  60 /* A file entry went away or appeared */
  61 static void show_file(const char *prefix, void *tree, unsigned long size, const char *base)
  62 {
  63         unsigned mode;
  64         const char *path;
  65         const unsigned char *sha1 = extract(tree, size, &path, &mode);
  66
  67         if (recursive && S_ISDIR(mode)) {
  68                 char type[20];
  69                 unsigned long size;
  70                 char *newbase = malloc_base(base, path, strlen(path));
  71                 void *tree;
  72
  73                 tree = read_sha1_file(sha1, type, &size);
  74                 if (!tree || strcmp(type, "tree"))
  75                         die("corrupt tree sha %s", sha1_to_hex(sha1));
  76
  77                 show_tree(prefix, tree, size, newbase);
  78
  79                 free(tree);
  80                 free(newbase);
  81                 return;
  82         }
  83
  84         if (generate_patch) {
  85                 if (!S_ISDIR(mode))
  86                         diff_addremove(prefix[0], mode, sha1, base, path);
  87         }
  88         else
  89                 printf("%s%06o\t%s\t%s\t%s%s%c", prefix, mode,
  90                        S_ISDIR(mode) ? "tree" : "blob",
  91                        sha1_to_hex(sha1), base, path,
  92                        line_termination);
  93 }
  94
  95 static int compare_tree_entry(void *tree1, unsigned long size1, void *tree2, unsigned long size2, const char *base)
  96 {
  97         unsigned mode1, mode2;
  98         const char *path1, *path2;
  99         const unsigned char *sha1, *sha2;
 100         int cmp, pathlen1, pathlen2;
 101         char old_sha1_hex[50];
 102
 103         sha1 = extract(tree1, size1, &path1, &mode1);
 104         sha2 = extract(tree2, size2, &path2, &mode2);
 105
 106         pathlen1 = strlen(path1);
 107         pathlen2 = strlen(path2);
 108         cmp = cache_name_compare(path1, pathlen1, path2, pathlen2);
 109         if (cmp < 0) {
 110                 show_file("-", tree1, size1, base);
 111                 return -1;
 112         }
 113         if (cmp > 0) {
 114                 show_file("+", tree2, size2, base);
 115                 return 1;
 116         }
 117         if (!memcmp(sha1, sha2, 20) && mode1 == mode2)
 118                 return 0;
 119
 120         /*
 121          * If the filemode has changed to/from a directory from/to a regular
 122          * file, we need to consider it a remove and an add.
 123          */
 124         if (S_ISDIR(mode1) != S_ISDIR(mode2)) {
 125                 show_file("-", tree1, size1, base);
 126                 show_file("+", tree2, size2, base);
 127                 return 0;
 128         }
 129
 130         if (recursive && S_ISDIR(mode1)) {
 131                 int retval;
 132                 char *newbase = malloc_base(base, path1, pathlen1);
 133                 retval = diff_tree_sha1(sha1, sha2, newbase);
 134                 free(newbase);
 135                 return retval;
 136         }
 137
 138         if (generate_patch) {
 139                 if (!S_ISDIR(mode1))
 140                         diff_change(mode1, mode2, sha1, sha2, base, path1);
 141         }
 142         else {
 143                 strcpy(old_sha1_hex, sha1_to_hex(sha1));
 144                 printf("*%06o->%06o\t%s\t%s->%s\t%s%s%c", mode1, mode2,
 145                        S_ISDIR(mode1) ? "tree" : "blob",
 146                        old_sha1_hex, sha1_to_hex(sha2), base, path1,
 147                        line_termination);
 148         }
 149         return 0;
 150 }
 151
 152 static int interesting(void *tree, unsigned long size, const char *base)
 153 {
 154         const char *path;
 155         unsigned mode;
 156         int i;
 157         int baselen, pathlen;
 158
 159         if (!nr_paths)
 160                 return 1;
 161
 162         (void)extract(tree, size, &path, &mode);
 163
 164         pathlen = strlen(path);
 165         baselen = strlen(base);
 166
 167         for (i=0; i < nr_paths; i++) {
 168                 const char *match = paths[i];
 169                 int matchlen = pathlens[i];
 170
 171                 if (baselen >= matchlen) {
 172                         /* If it doesn't match, move along... */
 173                         if (strncmp(base, match, matchlen))
 174                                 continue;
 175
 176                         /* The base is a subdirectory of a path which was specified. */
 177                         return 1;
 178                 }
 179
 180                 /* Does the base match? */
 181                 if (strncmp(base, match, baselen))
 182                         continue;
 183
 184                 match += baselen;
 185                 matchlen -= baselen;
 186
 187                 if (pathlen > matchlen)
 188                         continue;
 189
 190                 if (strncmp(path, match, pathlen))
 191                         continue;
 192
 193                 return 1;
 194         }
 195         return 0; /* No matches */
 196 }
 197
 198 static int diff_tree(void *tree1, unsigned long size1, void *tree2, unsigned long size2, const char *base)
 199 {
 200         while (size1 | size2) {
 201                 if (nr_paths && size1 && !interesting(tree1, size1, base)) {
 202                         update_tree_entry(&tree1, &size1);
 203                         continue;
 204                 }
 205                 if (nr_paths && size2 && !interesting(tree2, size2, base)) {
 206                         update_tree_entry(&tree2, &size2);
 207                         continue;
 208                 }
 209                 if (!size1) {
 210                         show_file("+", tree2, size2, base);
 211                         update_tree_entry(&tree2, &size2);
 212                         continue;
 213                 }
 214                 if (!size2) {
 215                         show_file("-", tree1, size1, base);
 216                         update_tree_entry(&tree1, &size1);
 217                         continue;
 218                 }
 219                 switch (compare_tree_entry(tree1, size1, tree2, size2, base)) {
 220                 case -1:
 221                         update_tree_entry(&tree1, &size1);
 222                         continue;
 223                 case 0:
 224                         update_tree_entry(&tree1, &size1);
 225                         /* Fallthrough */
 226                 case 1:
 227                         update_tree_entry(&tree2, &size2);
 228                         continue;
 229                 }
 230                 die("diff-tree: internal error");
 231         }
 232         return 0;
 233 }
 234
 235 static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base)
 236 {
 237         void *tree1, *tree2;
 238         unsigned long size1, size2;
 239         int retval;
 240
 241         tree1 = read_object_with_reference(old, "tree", &size1, 0);
 242         if (!tree1)
 243                 die("unable to read source tree (%s)", sha1_to_hex(old));
 244         tree2 = read_object_with_reference(new, "tree", &size2, 0);
 245         if (!tree2)
 246                 die("unable to read destination tree (%s)", sha1_to_hex(new));
 247         retval = diff_tree(tree1, size1, tree2, size2, base);
 248         free(tree1);
 249         free(tree2);
 250         return retval;
 251 }
 252
 253 static char *diff_tree_usage = "diff-tree [-p] [-r] [-z] <tree sha1> <tree sha1>";
 254
 255 int main(int argc, char **argv)
 256 {
 257         unsigned char old[20], new[20];
 258
 259         for (;;) {
 260                 char *arg = argv[1];
 261
 262                 if (!arg || *arg != '-')
 263                         break;
 264
 265                 argv++;
 266                 argc--;
 267                 if (!strcmp(arg, "-r")) {
 268                         recursive = 1;
 269                         continue;
 270                 }
 271                 if (!strcmp(arg, "-p")) {
 272                         recursive = generate_patch = 1;
 273                         continue;
 274                 }
 275                 if (!strcmp(arg, "-z")) {
 276                         line_termination = '\0';
 277                         continue;
 278                 }
 279                 usage(diff_tree_usage);
 280         }
 281
 282         if (argc < 3 || get_sha1(argv[1], old) || get_sha1(argv[2], new))
 283                 usage(diff_tree_usage);
 284
 285         if (argc > 3) {
 286                 int i;
 287
 288                 paths = &argv[3];
 289                 nr_paths = argc - 3;
 290                 pathlens = xmalloc(nr_paths * sizeof(int));
 291                 for (i=0; i<nr_paths; i++)
 292                         pathlens[i] = strlen(paths[i]);
 293         }
 294
 295         return diff_tree_sha1(old, new, "");
 296 }