match-trees.c

   1 #include "cache.h"
   2 #include "tree.h"
   3 #include "tree-walk.h"
   4
   5 static int score_missing(unsigned mode, const char *path)
   6 {
   7         int score;
   8
   9         if (S_ISDIR(mode))
  10                 score = -1000;
  11         else if (S_ISLNK(mode))
  12                 score = -500;
  13         else
  14                 score = -50;
  15         return score;
  16 }
  17
  18 static int score_differs(unsigned mode1, unsigned mode2, const char *path)
  19 {
  20         int score;
  21
  22         if (S_ISDIR(mode1) != S_ISDIR(mode2))
  23                 score = -100;
  24         else if (S_ISLNK(mode1) != S_ISLNK(mode2))
  25                 score = -50;
  26         else
  27                 score = -5;
  28         return score;
  29 }
  30
  31 static int score_matches(unsigned mode1, unsigned mode2, const char *path)
  32 {
  33         int score;
  34
  35         /* Heh, we found SHA-1 collisions between different kind of objects */
  36         if (S_ISDIR(mode1) != S_ISDIR(mode2))
  37                 score = -100;
  38         else if (S_ISLNK(mode1) != S_ISLNK(mode2))
  39                 score = -50;
  40
  41         else if (S_ISDIR(mode1))
  42                 score = 1000;
  43         else if (S_ISLNK(mode1))
  44                 score = 500;
  45         else
  46                 score = 250;
  47         return score;
  48 }
  49
  50 static int base_name_entries_compare(const struct name_entry *a,
  51                                      const struct name_entry *b)
  52 {
  53         return base_name_compare(a->path, tree_entry_len(a), a->mode,
  54                                  b->path, tree_entry_len(b), b->mode);
  55 }
  56
  57 /*
  58  * Inspect two trees, and give a score that tells how similar they are.
  59  */
  60 static int score_trees(const unsigned char *hash1, const unsigned char *hash2)
  61 {
  62         struct tree_desc one;
  63         struct tree_desc two;
  64         void *one_buf, *two_buf;
  65         int score = 0;
  66         enum object_type type;
  67         unsigned long size;
  68
  69         one_buf = read_sha1_file(hash1, &type, &size);
  70         if (!one_buf)
  71                 die("unable to read tree (%s)", sha1_to_hex(hash1));
  72         if (type != OBJ_TREE)
  73                 die("%s is not a tree", sha1_to_hex(hash1));
  74         init_tree_desc(&one, one_buf, size);
  75         two_buf = read_sha1_file(hash2, &type, &size);
  76         if (!two_buf)
  77                 die("unable to read tree (%s)", sha1_to_hex(hash2));
  78         if (type != OBJ_TREE)
  79                 die("%s is not a tree", sha1_to_hex(hash2));
  80         init_tree_desc(&two, two_buf, size);
  81         for (;;) {
  82                 struct name_entry e1, e2;
  83                 int got_entry_from_one = tree_entry(&one, &e1);
  84                 int got_entry_from_two = tree_entry(&two, &e2);
  85                 int cmp;
  86
  87                 if (got_entry_from_one && got_entry_from_two)
  88                         cmp = base_name_entries_compare(&e1, &e2);
  89                 else if (got_entry_from_one)
  90                         /* two lacks this entry */
  91                         cmp = -1;
  92                 else if (got_entry_from_two)
  93                         /* two has more entries */
  94                         cmp = 1;
  95                 else
  96                         break;
  97
  98                 if (cmp < 0)
  99                         /* path1 does not appear in two */
 100                         score += score_missing(e1.mode, e1.path);
 101                 else if (cmp > 0)
 102                         /* path2 does not appear in one */
 103                         score += score_missing(e2.mode, e2.path);
 104                 else if (hashcmp(e1.sha1, e2.sha1))
 105                         /* they are different */
 106                         score += score_differs(e1.mode, e2.mode, e1.path);
 107                 else
 108                         /* same subtree or blob */
 109                         score += score_matches(e1.mode, e2.mode, e1.path);
 110         }
 111         free(one_buf);
 112         free(two_buf);
 113         return score;
 114 }
 115
 116 /*
 117  * Match one itself and its subtrees with two and pick the best match.
 118  */
 119 static void match_trees(const unsigned char *hash1,
 120                         const unsigned char *hash2,
 121                         int *best_score,
 122                         char **best_match,
 123                         const char *base,
 124                         int recurse_limit)
 125 {
 126         struct tree_desc one;
 127         void *one_buf;
 128         enum object_type type;
 129         unsigned long size;
 130
 131         one_buf = read_sha1_file(hash1, &type, &size);
 132         if (!one_buf)
 133                 die("unable to read tree (%s)", sha1_to_hex(hash1));
 134         if (type != OBJ_TREE)
 135                 die("%s is not a tree", sha1_to_hex(hash1));
 136         init_tree_desc(&one, one_buf, size);
 137
 138         while (one.size) {
 139                 const char *path;
 140                 const unsigned char *elem;
 141                 unsigned mode;
 142                 int score;
 143
 144                 elem = tree_entry_extract(&one, &path, &mode);
 145                 if (!S_ISDIR(mode))
 146                         goto next;
 147                 score = score_trees(elem, hash2);
 148                 if (*best_score < score) {
 149                         char *newpath;
 150                         newpath = xmalloc(strlen(base) + strlen(path) + 1);
 151                         sprintf(newpath, "%s%s", base, path);
 152                         free(*best_match);
 153                         *best_match = newpath;
 154                         *best_score = score;
 155                 }
 156                 if (recurse_limit) {
 157                         char *newbase;
 158                         newbase = xmalloc(strlen(base) + strlen(path) + 2);
 159                         sprintf(newbase, "%s%s/", base, path);
 160                         match_trees(elem, hash2, best_score, best_match,
 161                                     newbase, recurse_limit - 1);
 162                         free(newbase);
 163                 }
 164
 165         next:
 166                 update_tree_entry(&one);
 167         }
 168         free(one_buf);
 169 }
 170
 171 /*
 172  * A tree "hash1" has a subdirectory at "prefix".  Come up with a
 173  * tree object by replacing it with another tree "hash2".
 174  */
 175 static int splice_tree(const unsigned char *hash1,
 176                        const char *prefix,
 177                        const unsigned char *hash2,
 178                        unsigned char *result)
 179 {
 180         char *subpath;
 181         int toplen;
 182         char *buf;
 183         unsigned long sz;
 184         struct tree_desc desc;
 185         unsigned char *rewrite_here;
 186         const unsigned char *rewrite_with;
 187         unsigned char subtree[20];
 188         enum object_type type;
 189         int status;
 190
 191         subpath = strchr(prefix, '/');
 192         if (!subpath)
 193                 toplen = strlen(prefix);
 194         else {
 195                 toplen = subpath - prefix;
 196                 subpath++;
 197         }
 198
 199         buf = read_sha1_file(hash1, &type, &sz);
 200         if (!buf)
 201                 die("cannot read tree %s", sha1_to_hex(hash1));
 202         init_tree_desc(&desc, buf, sz);
 203
 204         rewrite_here = NULL;
 205         while (desc.size) {
 206                 const char *name;
 207                 unsigned mode;
 208                 const unsigned char *sha1;
 209
 210                 sha1 = tree_entry_extract(&desc, &name, &mode);
 211                 if (strlen(name) == toplen &&
 212                     !memcmp(name, prefix, toplen)) {
 213                         if (!S_ISDIR(mode))
 214                                 die("entry %s in tree %s is not a tree",
 215                                     name, sha1_to_hex(hash1));
 216                         rewrite_here = (unsigned char *) sha1;
 217                         break;
 218                 }
 219                 update_tree_entry(&desc);
 220         }
 221         if (!rewrite_here)
 222                 die("entry %.*s not found in tree %s",
 223                     toplen, prefix, sha1_to_hex(hash1));
 224         if (subpath) {
 225                 status = splice_tree(rewrite_here, subpath, hash2, subtree);
 226                 if (status)
 227                         return status;
 228                 rewrite_with = subtree;
 229         }
 230         else
 231                 rewrite_with = hash2;
 232         hashcpy(rewrite_here, rewrite_with);
 233         status = write_sha1_file(buf, sz, tree_type, result);
 234         free(buf);
 235         return status;
 236 }
 237
 238 /*
 239  * We are trying to come up with a merge between one and two that
 240  * results in a tree shape similar to one.  The tree two might
 241  * correspond to a subtree of one, in which case it needs to be
 242  * shifted down by prefixing otherwise empty directories.  On the
 243  * other hand, it could cover tree one and we might need to pick a
 244  * subtree of it.
 245  */
 246 void shift_tree(const unsigned char *hash1,
 247                 const unsigned char *hash2,
 248                 unsigned char *shifted,
 249                 int depth_limit)
 250 {
 251         char *add_prefix;
 252         char *del_prefix;
 253         int add_score, del_score;
 254
 255         /*
 256          * NEEDSWORK: this limits the recursion depth to hardcoded
 257          * value '2' to avoid excessive overhead.
 258          */
 259         if (!depth_limit)
 260                 depth_limit = 2;
 261
 262         add_score = del_score = score_trees(hash1, hash2);
 263         add_prefix = xcalloc(1, 1);
 264         del_prefix = xcalloc(1, 1);
 265
 266         /*
 267          * See if one's subtree resembles two; if so we need to prefix
 268          * two with a few fake trees to match the prefix.
 269          */
 270         match_trees(hash1, hash2, &add_score, &add_prefix, "", depth_limit);
 271
 272         /*
 273          * See if two's subtree resembles one; if so we need to
 274          * pick only subtree of two.
 275          */
 276         match_trees(hash2, hash1, &del_score, &del_prefix, "", depth_limit);
 277
 278         /* Assume we do not have to do any shifting */
 279         hashcpy(shifted, hash2);
 280
 281         if (add_score < del_score) {
 282                 /* We need to pick a subtree of two */
 283                 unsigned mode;
 284
 285                 if (!*del_prefix)
 286                         return;
 287
 288                 if (get_tree_entry(hash2, del_prefix, shifted, &mode))
 289                         die("cannot find path %s in tree %s",
 290                             del_prefix, sha1_to_hex(hash2));
 291                 return;
 292         }
 293
 294         if (!*add_prefix)
 295                 return;
 296
 297         splice_tree(hash1, add_prefix, hash2, shifted);
 298 }
 299
 300 /*
 301  * The user says the trees will be shifted by this much.
 302  * Unfortunately we cannot fundamentally tell which one to
 303  * be prefixed, as recursive merge can work in either direction.
 304  */
 305 void shift_tree_by(const unsigned char *hash1,
 306                    const unsigned char *hash2,
 307                    unsigned char *shifted,
 308                    const char *shift_prefix)
 309 {
 310         unsigned char sub1[20], sub2[20];
 311         unsigned mode1, mode2;
 312         unsigned candidate = 0;
 313
 314         /* Can hash2 be a tree at shift_prefix in tree hash1? */
 315         if (!get_tree_entry(hash1, shift_prefix, sub1, &mode1) &&
 316             S_ISDIR(mode1))
 317                 candidate |= 1;
 318
 319         /* Can hash1 be a tree at shift_prefix in tree hash2? */
 320         if (!get_tree_entry(hash2, shift_prefix, sub2, &mode2) &&
 321             S_ISDIR(mode2))
 322                 candidate |= 2;
 323
 324         if (candidate == 3) {
 325                 /* Both are plausible -- we need to evaluate the score */
 326                 int best_score = score_trees(hash1, hash2);
 327                 int score;
 328
 329                 candidate = 0;
 330                 score = score_trees(sub1, hash2);
 331                 if (score > best_score) {
 332                         candidate = 1;
 333                         best_score = score;
 334                 }
 335                 score = score_trees(sub2, hash1);
 336                 if (score > best_score)
 337                         candidate = 2;
 338         }
 339
 340         if (!candidate) {
 341                 /* Neither is plausible -- do not shift */
 342                 hashcpy(shifted, hash2);
 343                 return;
 344         }
 345
 346         if (candidate == 1)
 347                 /*
 348                  * shift tree2 down by adding shift_prefix above it
 349                  * to match tree1.
 350                  */
 351                 splice_tree(hash1, shift_prefix, hash2, shifted);
 352         else
 353                 /*
 354                  * shift tree2 up by removing shift_prefix from it
 355                  * to match tree1.
 356                  */
 357                 hashcpy(shifted, sub2);
 358 }