1a575eb0d29d298ab714c7455cff5b6eced4de2f
   1/*
   2 * GIT - The information manager from hell
   3 *
   4 * Copyright (C) Linus Torvalds, 2005
   5 */
   6#include "cache.h"
   7
   8static int stage = 0;
   9static int update = 0;
  10
  11static int unpack_tree(unsigned char *sha1)
  12{
  13        void *buffer;
  14        unsigned long size;
  15        int ret;
  16
  17        buffer = read_object_with_reference(sha1, "tree", &size, NULL);
  18        if (!buffer)
  19                return -1;
  20        ret = read_tree(buffer, size, stage);
  21        free(buffer);
  22        return ret;
  23}
  24
  25static char *lockfile_name;
  26
  27static void remove_lock_file(void)
  28{
  29        if (lockfile_name)
  30                unlink(lockfile_name);
  31}
  32
  33static int path_matches(struct cache_entry *a, struct cache_entry *b)
  34{
  35        int len = ce_namelen(a);
  36        return ce_namelen(b) == len &&
  37                !memcmp(a->name, b->name, len);
  38}
  39
  40static int same(struct cache_entry *a, struct cache_entry *b)
  41{
  42        return a->ce_mode == b->ce_mode && 
  43                !memcmp(a->sha1, b->sha1, 20);
  44}
  45
  46
  47/*
  48 * This removes all trivial merges that don't change the tree
  49 * and collapses them to state 0.
  50 *
  51 * _Any_ other merge is left to user policy.  That includes "both
  52 * created the same file", and "both removed the same file" - which are
  53 * trivial, but the user might still want to _note_ it. 
  54 */
  55static struct cache_entry *merge_entries(struct cache_entry *a,
  56                                         struct cache_entry *b,
  57                                         struct cache_entry *c)
  58{
  59        int len = ce_namelen(a);
  60
  61        /*
  62         * Are they all the same filename? We won't do
  63         * any name merging
  64         */
  65        if (ce_namelen(b) != len ||
  66            ce_namelen(c) != len ||
  67            memcmp(a->name, b->name, len) ||
  68            memcmp(a->name, c->name, len))
  69                return NULL;
  70
  71        /*
  72         * Ok, all three entries describe the same
  73         * filename, but maybe the contents or file
  74         * mode have changed?
  75         *
  76         * The trivial cases end up being the ones where two
  77         * out of three files are the same:
  78         *  - both destinations the same, trivially take either
  79         *  - one of the destination versions hasn't changed,
  80         *    take the other.
  81         *
  82         * The "all entries exactly the same" case falls out as
  83         * a special case of any of the "two same" cases.
  84         *
  85         * Here "a" is "original", and "b" and "c" are the two
  86         * trees we are merging.
  87         */
  88        if (same(b,c))
  89                return c;
  90        if (same(a,b))
  91                return c;
  92        if (same(a,c))
  93                return b;
  94        return NULL;
  95}
  96
  97/*
  98 * When a CE gets turned into an unmerged entry, we
  99 * want it to be up-to-date
 100 */
 101static void verify_uptodate(struct cache_entry *ce)
 102{
 103        struct stat st;
 104
 105        if (!lstat(ce->name, &st)) {
 106                unsigned changed = ce_match_stat(ce, &st);
 107                if (!changed)
 108                        return;
 109                errno = 0;
 110        }
 111        if (errno == ENOENT)
 112                return;
 113        die("Entry '%s' not uptodate. Cannot merge.", ce->name);
 114}
 115
 116/*
 117 * If the old tree contained a CE that isn't even in the
 118 * result, that's always a problem, regardless of whether
 119 * it's up-to-date or not (ie it can be a file that we
 120 * have updated but not committed yet).
 121 */
 122static void reject_merge(struct cache_entry *ce)
 123{
 124        die("Entry '%s' would be overwritten by merge. Cannot merge.", ce->name);
 125}
 126
 127#define CHECK_OLD(ce) if (old && same(old, ce)) { verify_uptodate(old); old = NULL; }
 128
 129static void trivially_merge_cache(struct cache_entry **src, int nr)
 130{
 131        struct cache_entry **dst = src;
 132        struct cache_entry *old = NULL;
 133
 134        while (nr--) {
 135                struct cache_entry *ce, *result;
 136
 137                ce = *src++;
 138
 139                /* We throw away original cache entries except for the stat information */
 140                if (!ce_stage(ce)) {
 141                        if (old)
 142                                reject_merge(old);
 143                        old = ce;
 144                        active_nr--;
 145                        continue;
 146                }
 147                if (old && !path_matches(old, ce))
 148                        reject_merge(old);
 149                if (nr > 2 && (result = merge_entries(ce, src[1], src[2])) != NULL) {
 150                        result->ce_flags |= htons(CE_UPDATE);
 151                        /*
 152                         * See if we can re-use the old CE directly?
 153                         * That way we get the uptodate stat info.
 154                         *
 155                         * This also removes the UPDATE flag on
 156                         * a match.
 157                         */
 158                        if (old && same(old, result)) {
 159                                *result = *old;
 160                                old = NULL;
 161                        }
 162                        CHECK_OLD(ce);
 163                        CHECK_OLD(src[1]);
 164                        CHECK_OLD(src[2]);
 165                        ce = result;
 166                        ce->ce_flags &= ~htons(CE_STAGEMASK);
 167                        src += 2;
 168                        nr -= 2;
 169                        active_nr -= 2;
 170                }
 171
 172                /*
 173                 * If we had an old entry that we now effectively
 174                 * overwrite, make sure it wasn't dirty.
 175                 */
 176                CHECK_OLD(ce);
 177                *dst++ = ce;
 178        }
 179        if (old)
 180                reject_merge(old);
 181}
 182
 183/*
 184 * Two-way merge.
 185 *
 186 * The rule is: 
 187 *  - every current entry has to match the old tree
 188 *  - if the current entry matches the new tree, we leave it
 189 *    as-is. Otherwise we require that it be up-to-date.
 190 */
 191static void twoway_merge(struct cache_entry **src, int nr)
 192{
 193        static struct cache_entry null_entry;
 194        struct cache_entry *old = NULL, *stat = &null_entry;
 195        struct cache_entry **dst = src;
 196
 197        while (nr--) {
 198                struct cache_entry *ce = *src++;
 199                int stage = ce_stage(ce);
 200
 201                switch (stage) {
 202                case 0:
 203                        if (old)
 204                                reject_merge(old);
 205                        old = ce;
 206                        stat = ce;
 207                        active_nr--;
 208                        continue;
 209
 210                case 1:
 211                        active_nr--;
 212                        if (!old)
 213                                continue;
 214                        if (!path_matches(old, ce) || !same(old, ce))
 215                                reject_merge(old);
 216                        continue;
 217
 218                case 2:
 219                        ce->ce_flags |= htons(CE_UPDATE);
 220                        if (old) {
 221                                if (!path_matches(old, ce))
 222                                        reject_merge(old);
 223                                /*
 224                                 * This also removes the UPDATE flag on
 225                                 * a match
 226                                 */
 227                                if (same(old, ce))
 228                                        *ce = *old;
 229                                else
 230                                        verify_uptodate(old);
 231                                old = NULL;
 232                        }
 233                        ce->ce_flags &= ~htons(CE_STAGEMASK);
 234                        *dst++ = ce;
 235                        continue;
 236                }
 237                die("impossible two-way stage");
 238        }
 239        if (old)
 240                reject_merge(old);
 241}
 242
 243static void merge_stat_info(struct cache_entry **src, int nr)
 244{
 245        static struct cache_entry null_entry;
 246        struct cache_entry **dst = src;
 247        struct cache_entry *stat = &null_entry;
 248
 249        while (nr--) {
 250                struct cache_entry *ce = *src++;
 251
 252                /* We throw away original cache entries except for the stat information */
 253                if (!ce_stage(ce)) {
 254                        stat = ce;
 255                        active_nr--;
 256                        continue;
 257                }
 258                if (path_matches(ce, stat) && same(ce, stat))
 259                        *ce = *stat;
 260                ce->ce_flags &= ~htons(CE_STAGEMASK);
 261                *dst++ = ce;
 262        }
 263}
 264
 265static void check_updates(struct cache_entry **src, int nr)
 266{
 267        static struct checkout state = {
 268                .base_dir = "",
 269                .force = 1,
 270                .quiet = 1,
 271                .refresh_cache = 1,
 272        };
 273        unsigned short mask = htons(CE_UPDATE);
 274        while (nr--) {
 275                struct cache_entry *ce = *src++;
 276                if (ce->ce_flags & mask) {
 277                        ce->ce_flags &= ~mask;
 278                        if (update)
 279                                checkout_entry(ce, &state);
 280                }
 281        }
 282}
 283
 284static char *read_tree_usage = "git-read-tree (<sha> | -m <sha1> [<sha2> [<sha3>]])";
 285
 286int main(int argc, char **argv)
 287{
 288        int i, newfd, merge;
 289        unsigned char sha1[20];
 290        static char lockfile[MAXPATHLEN+1];
 291        const char *indexfile = get_index_file();
 292
 293        snprintf(lockfile, sizeof(lockfile), "%s.lock", indexfile);
 294
 295        newfd = open(lockfile, O_RDWR | O_CREAT | O_EXCL, 0600);
 296        if (newfd < 0)
 297                die("unable to create new cachefile");
 298        atexit(remove_lock_file);
 299        lockfile_name = lockfile;
 300
 301        merge = 0;
 302        for (i = 1; i < argc; i++) {
 303                const char *arg = argv[i];
 304
 305                /* "-u" means "update", meaning that a merge will update the working directory */
 306                if (!strcmp(arg, "-u")) {
 307                        update = 1;
 308                        continue;
 309                }
 310
 311                /* "-m" stands for "merge", meaning we start in stage 1 */
 312                if (!strcmp(arg, "-m")) {
 313                        int i;
 314                        if (stage)
 315                                die("-m needs to come first");
 316                        read_cache();
 317                        for (i = 0; i < active_nr; i++) {
 318                                if (ce_stage(active_cache[i]))
 319                                        die("you need to resolve your current index first");
 320                        }
 321                        stage = 1;
 322                        merge = 1;
 323                        continue;
 324                }
 325                if (get_sha1(arg, sha1) < 0)
 326                        usage(read_tree_usage);
 327                if (stage > 3)
 328                        usage(read_tree_usage);
 329                if (unpack_tree(sha1) < 0)
 330                        die("failed to unpack tree object %s", arg);
 331                stage++;
 332        }
 333        if (merge) {
 334                switch (stage) {
 335                case 4: /* Three-way merge */
 336                        trivially_merge_cache(active_cache, active_nr);
 337                        check_updates(active_cache, active_nr);
 338                        break;
 339                case 3: /* Update from one tree to another */
 340                        twoway_merge(active_cache, active_nr);
 341                        check_updates(active_cache, active_nr);
 342                        break;
 343                case 2: /* Just read a tree, merge with old cache contents */
 344                        merge_stat_info(active_cache, active_nr);
 345                        break;
 346                default:
 347                        die("just how do you expect me to merge %d trees?", stage-1);
 348                }
 349        }
 350        if (write_cache(newfd, active_cache, active_nr) || rename(lockfile, indexfile))
 351                die("unable to write new index file");
 352        lockfile_name = NULL;
 353        return 0;
 354}