/* * A tree "hash1" has a subdirectory at "prefix". Come up with a * tree object by replacing it with another tree "hash2". */ static int splice_tree(const unsigned char *hash1, const char *prefix, const unsigned char *hash2, unsigned char *result) { char *subpath; int toplen; char *buf; unsigned long sz; struct tree_desc desc; unsigned char *rewrite_here; const unsigned char *rewrite_with; unsigned char subtree[20]; enum object_type type; int status; subpath = strchrnul(prefix, '/'); toplen = subpath - prefix; if (*subpath) subpath++; buf = read_sha1_file(hash1, &type, &sz); if (!buf) die("cannot read tree %s", sha1_to_hex(hash1)); init_tree_desc(&desc, buf, sz); rewrite_here = NULL; while (desc.size) { const char *name; unsigned mode; const unsigned char *sha1; sha1 = tree_entry_extract(&desc, &name, &mode); if (strlen(name) == toplen && !memcmp(name, prefix, toplen)) { if (!S_ISDIR(mode)) die("entry %s in tree %s is not a tree", name, sha1_to_hex(hash1)); rewrite_here = (unsigned char *) sha1; break; } update_tree_entry(&desc); } if (!rewrite_here) die("entry %.*s not found in tree %s", toplen, prefix, sha1_to_hex(hash1)); if (*subpath) { status = splice_tree(rewrite_here, subpath, hash2, subtree); if (status) return status; rewrite_with = subtree; } else rewrite_with = hash2; hashcpy(rewrite_here, rewrite_with); status = write_sha1_file(buf, sz, tree_type, result); free(buf); return status; }
/* * The user says the trees will be shifted by this much. * Unfortunately we cannot fundamentally tell which one to * be prefixed, as recursive merge can work in either direction. */ void shift_tree_by(const unsigned char *hash1, const unsigned char *hash2, unsigned char *shifted, const char *shift_prefix) { unsigned char sub1[20], sub2[20]; unsigned mode1, mode2; unsigned candidate = 0; /* Can hash2 be a tree at shift_prefix in tree hash1? */ if (!get_tree_entry(hash1, shift_prefix, sub1, &mode1) && S_ISDIR(mode1)) candidate |= 1; /* Can hash1 be a tree at shift_prefix in tree hash2? */ if (!get_tree_entry(hash2, shift_prefix, sub2, &mode2) && S_ISDIR(mode2)) candidate |= 2; if (candidate == 3) { /* Both are plausible -- we need to evaluate the score */ int best_score = score_trees(hash1, hash2); int score; candidate = 0; score = score_trees(sub1, hash2); if (score > best_score) { candidate = 1; best_score = score; } score = score_trees(sub2, hash1); if (score > best_score) candidate = 2; } if (!candidate) { /* Neither is plausible -- do not shift */ hashcpy(shifted, hash2); return; } if (candidate == 1) /* * shift tree2 down by adding shift_prefix above it * to match tree1. */ splice_tree(hash1, shift_prefix, hash2, shifted); else /* * shift tree2 up by removing shift_prefix from it * to match tree1. */ hashcpy(shifted, sub2); }
/* * We are trying to come up with a merge between one and two that * results in a tree shape similar to one. The tree two might * correspond to a subtree of one, in which case it needs to be * shifted down by prefixing otherwise empty directories. On the * other hand, it could cover tree one and we might need to pick a * subtree of it. */ void shift_tree(const unsigned char *hash1, const unsigned char *hash2, unsigned char *shifted, int depth_limit) { char *add_prefix; char *del_prefix; int add_score, del_score; /* * NEEDSWORK: this limits the recursion depth to hardcoded * value '2' to avoid excessive overhead. */ if (!depth_limit) depth_limit = 2; add_score = del_score = score_trees(hash1, hash2); add_prefix = xcalloc(1, 1); del_prefix = xcalloc(1, 1); /* * See if one's subtree resembles two; if so we need to prefix * two with a few fake trees to match the prefix. */ match_trees(hash1, hash2, &add_score, &add_prefix, "", depth_limit); /* * See if two's subtree resembles one; if so we need to * pick only subtree of two. */ match_trees(hash2, hash1, &del_score, &del_prefix, "", depth_limit); /* Assume we do not have to do any shifting */ hashcpy(shifted, hash2); if (add_score < del_score) { /* We need to pick a subtree of two */ unsigned mode; if (!*del_prefix) return; if (get_tree_entry(hash2, del_prefix, shifted, &mode)) die("cannot find path %s in tree %s", del_prefix, sha1_to_hex(hash2)); return; } if (!*add_prefix) return; splice_tree(hash1, add_prefix, hash2, shifted); }