Andrew's git - gitweb.git/blob

36578754ce854fea5ceb457af3630e10f9be9754
   1#!/usr/bin/python
   2
   3import sys, math, random, os, re, signal, tempfile, stat, errno, traceback
   4from heapq import heappush, heappop
   5from sets import Set
   6
   7sys.path.append('''@@GIT_PYTHON_PATH@@''')
   8from gitMergeCommon import *
   9
  10originalIndexFile = os.environ.get('GIT_INDEX_FILE',
  11                                   os.environ.get('GIT_DIR', '.git') + '/index')
  12temporaryIndexFile = os.environ.get('GIT_DIR', '.git') + \
  13                     '/merge-recursive-tmp-index'
  14def setupIndex(temporary):
  15    try:
  16        os.unlink(temporaryIndexFile)
  17    except OSError:
  18        pass
  19    if temporary:
  20        newIndex = temporaryIndexFile
  21    else:
  22        newIndex = originalIndexFile
  23    os.environ['GIT_INDEX_FILE'] = newIndex
  24
  25# This is a global variable which is used in a number of places but
  26# only written to in the 'merge' function.
  27
  28# cacheOnly == True  => Don't leave any non-stage 0 entries in the cache and
  29#                       don't update the working directory.
  30#              False => Leave unmerged entries in the cache and update
  31#                       the working directory.
  32
  33cacheOnly = False
  34
  35# The entry point to the merge code
  36# ---------------------------------
  37
  38def merge(h1, h2, branch1Name, branch2Name, graph, callDepth=0):
  39    '''Merge the commits h1 and h2, return the resulting virtual
  40    commit object and a flag indicating the cleaness of the merge.'''
  41    assert(isinstance(h1, Commit) and isinstance(h2, Commit))
  42    assert(isinstance(graph, Graph))
  43
  44    def infoMsg(*args):
  45        sys.stdout.write('  '*callDepth)
  46        printList(args)
  47
  48    infoMsg('Merging:')
  49    infoMsg(h1)
  50    infoMsg(h2)
  51    sys.stdout.flush()
  52
  53    ca = getCommonAncestors(graph, h1, h2)
  54    infoMsg('found', len(ca), 'common ancestor(s):')
  55    for x in ca:
  56        infoMsg(x)
  57    sys.stdout.flush()
  58
  59    mergedCA = ca[0]
  60    for h in ca[1:]:
  61        [mergedCA, dummy] = merge(mergedCA, h,
  62                                  'Temporary shared merge branch 1',
  63                                  'Temporary shared merge branch 2',
  64                                  graph, callDepth+1)
  65        assert(isinstance(mergedCA, Commit))
  66
  67    global cacheOnly
  68    if callDepth == 0:
  69        setupIndex(False)
  70        cacheOnly = False
  71    else:
  72        setupIndex(True)
  73        runProgram(['git-read-tree', h1.tree()])
  74        cacheOnly = True
  75
  76    [shaRes, clean] = mergeTrees(h1.tree(), h2.tree(), mergedCA.tree(),
  77                                 branch1Name, branch2Name)
  78
  79    if clean or cacheOnly:
  80        res = Commit(None, [h1, h2], tree=shaRes)
  81        graph.addNode(res)
  82    else:
  83        res = None
  84
  85    return [res, clean]
  86
  87getFilesRE = re.compile(r'^([0-7]+) (\S+) ([0-9a-f]{40})\t(.*)$', re.S)
  88def getFilesAndDirs(tree):
  89    files = Set()
  90    dirs = Set()
  91    out = runProgram(['git-ls-tree', '-r', '-z', tree])
  92    for l in out.split('\0'):
  93        m = getFilesRE.match(l)
  94        if m:
  95            if m.group(2) == 'tree':
  96                dirs.add(m.group(4))
  97            elif m.group(2) == 'blob':
  98                files.add(m.group(4))
  99
 100    return [files, dirs]
 101
 102# Those two global variables are used in a number of places but only
 103# written to in 'mergeTrees' and 'uniquePath'. They keep track of
 104# every file and directory in the two branches that are about to be
 105# merged.
 106currentFileSet = None
 107currentDirectorySet = None
 108
 109def mergeTrees(head, merge, common, branch1Name, branch2Name):
 110    '''Merge the trees 'head' and 'merge' with the common ancestor
 111    'common'. The name of the head branch is 'branch1Name' and the name of
 112    the merge branch is 'branch2Name'. Return a tuple (tree, cleanMerge)
 113    where tree is the resulting tree and cleanMerge is True iff the
 114    merge was clean.'''
 115    
 116    assert(isSha(head) and isSha(merge) and isSha(common))
 117
 118    if common == merge:
 119        print 'Already uptodate!'
 120        return [head, True]
 121
 122    if cacheOnly:
 123        updateArg = '-i'
 124    else:
 125        updateArg = '-u'
 126
 127    [out, code] = runProgram(['git-read-tree', updateArg, '-m',
 128                                common, head, merge], returnCode = True)
 129    if code != 0:
 130        die('git-read-tree:', out)
 131
 132    [tree, code] = runProgram('git-write-tree', returnCode=True)
 133    tree = tree.rstrip()
 134    if code != 0:
 135        global currentFileSet, currentDirectorySet
 136        [currentFileSet, currentDirectorySet] = getFilesAndDirs(head)
 137        [filesM, dirsM] = getFilesAndDirs(merge)
 138        currentFileSet.union_update(filesM)
 139        currentDirectorySet.union_update(dirsM)
 140
 141        entries = unmergedCacheEntries()
 142        renamesHead =  getRenames(head, common, head, merge, entries)
 143        renamesMerge = getRenames(merge, common, head, merge, entries)
 144
 145        cleanMerge = processRenames(renamesHead, renamesMerge,
 146                                    branch1Name, branch2Name)
 147        for entry in entries:
 148            if entry.processed:
 149                continue
 150            if not processEntry(entry, branch1Name, branch2Name):
 151                cleanMerge = False
 152                
 153        if cleanMerge or cacheOnly:
 154            tree = runProgram('git-write-tree').rstrip()
 155        else:
 156            tree = None
 157    else:
 158        cleanMerge = True
 159
 160    return [tree, cleanMerge]
 161
 162# Low level file merging, update and removal
 163# ------------------------------------------
 164
 165def mergeFile(oPath, oSha, oMode, aPath, aSha, aMode, bPath, bSha, bMode,
 166              branch1Name, branch2Name):
 167
 168    merge = False
 169    clean = True
 170
 171    if stat.S_IFMT(aMode) != stat.S_IFMT(bMode):
 172        clean = False
 173        if stat.S_ISREG(aMode):
 174            mode = aMode
 175            sha = aSha
 176        else:
 177            mode = bMode
 178            sha = bSha
 179    else:
 180        if aSha != oSha and bSha != oSha:
 181            merge = True
 182
 183        if aMode == oMode:
 184            mode = bMode
 185        else:
 186            mode = aMode
 187
 188        if aSha == oSha:
 189            sha = bSha
 190        elif bSha == oSha:
 191            sha = aSha
 192        elif stat.S_ISREG(aMode):
 193            assert(stat.S_ISREG(bMode))
 194
 195            orig = runProgram(['git-unpack-file', oSha]).rstrip()
 196            src1 = runProgram(['git-unpack-file', aSha]).rstrip()
 197            src2 = runProgram(['git-unpack-file', bSha]).rstrip()
 198            [out, code] = runProgram(['merge',
 199                                      '-L', branch1Name + '/' + aPath,
 200                                      '-L', 'orig/' + oPath,
 201                                      '-L', branch2Name + '/' + bPath,
 202                                      src1, orig, src2], returnCode=True)
 203
 204            sha = runProgram(['git-hash-object', '-t', 'blob', '-w',
 205                              src1]).rstrip()
 206
 207            os.unlink(orig)
 208            os.unlink(src1)
 209            os.unlink(src2)
 210
 211            clean = (code == 0)
 212        else:
 213            assert(stat.S_ISLNK(aMode) and stat.S_ISLNK(bMode))
 214            sha = aSha
 215
 216            if aSha != bSha:
 217                clean = False
 218
 219    return [sha, mode, clean, merge]
 220
 221def updateFile(clean, sha, mode, path):
 222    updateCache = cacheOnly or clean
 223    updateWd = not cacheOnly
 224
 225    return updateFileExt(sha, mode, path, updateCache, updateWd)
 226
 227def updateFileExt(sha, mode, path, updateCache, updateWd):
 228    if cacheOnly:
 229        updateWd = False
 230
 231    if updateWd:
 232        pathComponents = path.split('/')
 233        for x in xrange(1, len(pathComponents)):
 234            p = '/'.join(pathComponents[0:x])
 235
 236            try:
 237                createDir = not stat.S_ISDIR(os.lstat(p).st_mode)
 238            except: 
 239                createDir = True
 240            
 241            if createDir:
 242                try:
 243                    os.mkdir(p)
 244                except OSError, e:
 245                    die("Couldn't create directory", p, e.strerror)
 246
 247        prog = ['git-cat-file', 'blob', sha]
 248        if stat.S_ISREG(mode):
 249            try:
 250                os.unlink(path)
 251            except OSError:
 252                pass
 253            if mode & 0100:
 254                mode = 0777
 255            else:
 256                mode = 0666
 257            fd = os.open(path, os.O_WRONLY | os.O_TRUNC | os.O_CREAT, mode)
 258            proc = subprocess.Popen(prog, stdout=fd)
 259            proc.wait()
 260            os.close(fd)
 261        elif stat.S_ISLNK(mode):
 262            linkTarget = runProgram(prog)
 263            os.symlink(linkTarget, path)
 264        else:
 265            assert(False)
 266
 267    if updateWd and updateCache:
 268        runProgram(['git-update-index', '--add', '--', path])
 269    elif updateCache:
 270        runProgram(['git-update-index', '--add', '--cacheinfo',
 271                    '0%o' % mode, sha, path])
 272
 273def removeFile(clean, path):
 274    updateCache = cacheOnly or clean
 275    updateWd = not cacheOnly
 276
 277    if updateCache:
 278        runProgram(['git-update-index', '--force-remove', '--', path])
 279
 280    if updateWd:
 281        try:
 282            os.unlink(path)
 283        except OSError, e:
 284            if e.errno != errno.ENOENT and e.errno != errno.EISDIR:
 285                raise
 286
 287def uniquePath(path, branch):
 288    def fileExists(path):
 289        try:
 290            os.lstat(path)
 291            return True
 292        except OSError, e:
 293            if e.errno == errno.ENOENT:
 294                return False
 295            else:
 296                raise
 297
 298    newPath = path + '_' + branch
 299    suffix = 0
 300    while newPath in currentFileSet or \
 301          newPath in currentDirectorySet  or \
 302          fileExists(newPath):
 303        suffix += 1
 304        newPath = path + '_' + branch + '_' + str(suffix)
 305    currentFileSet.add(newPath)
 306    return newPath
 307
 308# Cache entry management
 309# ----------------------
 310
 311class CacheEntry:
 312    def __init__(self, path):
 313        class Stage:
 314            def __init__(self):
 315                self.sha1 = None
 316                self.mode = None
 317
 318            # Used for debugging only
 319            def __str__(self):
 320                if self.mode != None:
 321                    m = '0%o' % self.mode
 322                else:
 323                    m = 'None'
 324
 325                if self.sha1:
 326                    sha1 = self.sha1
 327                else:
 328                    sha1 = 'None'
 329                return 'sha1: ' + sha1 + ' mode: ' + m
 330        
 331        self.stages = [Stage(), Stage(), Stage(), Stage()]
 332        self.path = path
 333        self.processed = False
 334
 335    def __str__(self):
 336        return 'path: ' + self.path + ' stages: ' + repr([str(x) for x in self.stages])
 337
 338class CacheEntryContainer:
 339    def __init__(self):
 340        self.entries = {}
 341
 342    def add(self, entry):
 343        self.entries[entry.path] = entry
 344
 345    def get(self, path):
 346        return self.entries.get(path)
 347
 348    def __iter__(self):
 349        return self.entries.itervalues()
 350    
 351unmergedRE = re.compile(r'^([0-7]+) ([0-9a-f]{40}) ([1-3])\t(.*)$', re.S)
 352def unmergedCacheEntries():
 353    '''Create a dictionary mapping file names to CacheEntry
 354    objects. The dictionary contains one entry for every path with a
 355    non-zero stage entry.'''
 356
 357    lines = runProgram(['git-ls-files', '-z', '--unmerged']).split('\0')
 358    lines.pop()
 359
 360    res = CacheEntryContainer()
 361    for l in lines:
 362        m = unmergedRE.match(l)
 363        if m:
 364            mode = int(m.group(1), 8)
 365            sha1 = m.group(2)
 366            stage = int(m.group(3))
 367            path = m.group(4)
 368
 369            e = res.get(path)
 370            if not e:
 371                e = CacheEntry(path)
 372                res.add(e)
 373
 374            e.stages[stage].mode = mode
 375            e.stages[stage].sha1 = sha1
 376        else:
 377            die('Error: Merge program failed: Unexpected output from',
 378                'git-ls-files:', l)
 379    return res
 380
 381lsTreeRE = re.compile(r'^([0-7]+) (\S+) ([0-9a-f]{40})\t(.*)\n$', re.S)
 382def getCacheEntry(path, origTree, aTree, bTree):
 383    '''Returns a CacheEntry object which doesn't have to correspond to
 384    a real cache entry in Git's index.'''
 385    
 386    def parse(out):
 387        if out == '':
 388            return [None, None]
 389        else:
 390            m = lsTreeRE.match(out)
 391            if not m:
 392                die('Unexpected output from git-ls-tree:', out)
 393            elif m.group(2) == 'blob':
 394                return [m.group(3), int(m.group(1), 8)]
 395            else:
 396                return [None, None]
 397
 398    res = CacheEntry(path)
 399
 400    [oSha, oMode] = parse(runProgram(['git-ls-tree', origTree, '--', path]))
 401    [aSha, aMode] = parse(runProgram(['git-ls-tree', aTree, '--', path]))
 402    [bSha, bMode] = parse(runProgram(['git-ls-tree', bTree, '--', path]))
 403
 404    res.stages[1].sha1 = oSha
 405    res.stages[1].mode = oMode
 406    res.stages[2].sha1 = aSha
 407    res.stages[2].mode = aMode
 408    res.stages[3].sha1 = bSha
 409    res.stages[3].mode = bMode
 410
 411    return res
 412
 413# Rename detection and handling
 414# -----------------------------
 415
 416class RenameEntry:
 417    def __init__(self,
 418                 src, srcSha, srcMode, srcCacheEntry,
 419                 dst, dstSha, dstMode, dstCacheEntry,
 420                 score):
 421        self.srcName = src
 422        self.srcSha = srcSha
 423        self.srcMode = srcMode
 424        self.srcCacheEntry = srcCacheEntry
 425        self.dstName = dst
 426        self.dstSha = dstSha
 427        self.dstMode = dstMode
 428        self.dstCacheEntry = dstCacheEntry
 429        self.score = score
 430
 431        self.processed = False
 432
 433class RenameEntryContainer:
 434    def __init__(self):
 435        self.entriesSrc = {}
 436        self.entriesDst = {}
 437
 438    def add(self, entry):
 439        self.entriesSrc[entry.srcName] = entry
 440        self.entriesDst[entry.dstName] = entry
 441
 442    def getSrc(self, path):
 443        return self.entriesSrc.get(path)
 444
 445    def getDst(self, path):
 446        return self.entriesDst.get(path)
 447
 448    def __iter__(self):
 449        return self.entriesSrc.itervalues()
 450
 451parseDiffRenamesRE = re.compile('^:([0-7]+) ([0-7]+) ([0-9a-f]{40}) ([0-9a-f]{40}) R([0-9]*)$')
 452def getRenames(tree, oTree, aTree, bTree, cacheEntries):
 453    '''Get information of all renames which occured between 'oTree' and
 454    'tree'. We need the three trees in the merge ('oTree', 'aTree' and
 455    'bTree') to be able to associate the correct cache entries with
 456    the rename information. 'tree' is always equal to either aTree or bTree.'''
 457
 458    assert(tree == aTree or tree == bTree)
 459    inp = runProgram(['git-diff-tree', '-M', '--diff-filter=R', '-r',
 460                      '-z', oTree, tree])
 461
 462    ret = RenameEntryContainer()
 463    try:
 464        recs = inp.split("\0")
 465        recs.pop() # remove last entry (which is '')
 466        it = recs.__iter__()
 467        while True:
 468            rec = it.next()
 469            m = parseDiffRenamesRE.match(rec)
 470
 471            if not m:
 472                die('Unexpected output from git-diff-tree:', rec)
 473
 474            srcMode = int(m.group(1), 8)
 475            dstMode = int(m.group(2), 8)
 476            srcSha = m.group(3)
 477            dstSha = m.group(4)
 478            score = m.group(5)
 479            src = it.next()
 480            dst = it.next()
 481
 482            srcCacheEntry = cacheEntries.get(src)
 483            if not srcCacheEntry:
 484                srcCacheEntry = getCacheEntry(src, oTree, aTree, bTree)
 485                cacheEntries.add(srcCacheEntry)
 486
 487            dstCacheEntry = cacheEntries.get(dst)
 488            if not dstCacheEntry:
 489                dstCacheEntry = getCacheEntry(dst, oTree, aTree, bTree)
 490                cacheEntries.add(dstCacheEntry)
 491
 492            ret.add(RenameEntry(src, srcSha, srcMode, srcCacheEntry,
 493                                dst, dstSha, dstMode, dstCacheEntry,
 494                                score))
 495    except StopIteration:
 496        pass
 497    return ret
 498
 499def fmtRename(src, dst):
 500    srcPath = src.split('/')
 501    dstPath = dst.split('/')
 502    path = []
 503    endIndex = min(len(srcPath), len(dstPath)) - 1
 504    for x in range(0, endIndex):
 505        if srcPath[x] == dstPath[x]:
 506            path.append(srcPath[x])
 507        else:
 508            endIndex = x
 509            break
 510
 511    if len(path) > 0:
 512        return '/'.join(path) + \
 513               '/{' + '/'.join(srcPath[endIndex:]) + ' => ' + \
 514               '/'.join(dstPath[endIndex:]) + '}'
 515    else:
 516        return src + ' => ' + dst
 517
 518def processRenames(renamesA, renamesB, branchNameA, branchNameB):
 519    srcNames = Set()
 520    for x in renamesA:
 521        srcNames.add(x.srcName)
 522    for x in renamesB:
 523        srcNames.add(x.srcName)
 524
 525    cleanMerge = True
 526    for path in srcNames:
 527        if renamesA.getSrc(path):
 528            renames1 = renamesA
 529            renames2 = renamesB
 530            branchName1 = branchNameA
 531            branchName2 = branchNameB
 532        else:
 533            renames1 = renamesB
 534            renames2 = renamesA
 535            branchName1 = branchNameB
 536            branchName2 = branchNameA
 537        
 538        ren1 = renames1.getSrc(path)
 539        ren2 = renames2.getSrc(path)
 540
 541        ren1.dstCacheEntry.processed = True
 542        ren1.srcCacheEntry.processed = True
 543
 544        if ren1.processed:
 545            continue
 546
 547        ren1.processed = True
 548        removeFile(True, ren1.srcName)
 549        if ren2:
 550            # Renamed in 1 and renamed in 2
 551            assert(ren1.srcName == ren2.srcName)
 552            ren2.dstCacheEntry.processed = True
 553            ren2.processed = True
 554
 555            if ren1.dstName != ren2.dstName:
 556                print 'CONFLICT (rename/rename): Rename', \
 557                      fmtRename(path, ren1.dstName), 'in branch', branchName1, \
 558                      'rename', fmtRename(path, ren2.dstName), 'in', branchName2
 559                cleanMerge = False
 560
 561                if ren1.dstName in currentDirectorySet:
 562                    dstName1 = uniquePath(ren1.dstName, branchName1)
 563                    print ren1.dstName, 'is a directory in', branchName2, \
 564                          'adding as', dstName1, 'instead.'
 565                    removeFile(False, ren1.dstName)
 566                else:
 567                    dstName1 = ren1.dstName
 568
 569                if ren2.dstName in currentDirectorySet:
 570                    dstName2 = uniquePath(ren2.dstName, branchName2)
 571                    print ren2.dstName, 'is a directory in', branchName1, \
 572                          'adding as', dstName2, 'instead.'
 573                    removeFile(False, ren2.dstName)
 574                else:
 575                    dstName2 = ren1.dstName
 576
 577                updateFile(False, ren1.dstSha, ren1.dstMode, dstName1)
 578                updateFile(False, ren2.dstSha, ren2.dstMode, dstName2)
 579            else:
 580                [resSha, resMode, clean, merge] = \
 581                         mergeFile(ren1.srcName, ren1.srcSha, ren1.srcMode,
 582                                   ren1.dstName, ren1.dstSha, ren1.dstMode,
 583                                   ren2.dstName, ren2.dstSha, ren2.dstMode,
 584                                   branchName1, branchName2)
 585
 586                if merge or not clean:
 587                    print 'Renaming', fmtRename(path, ren1.dstName)
 588
 589                if merge:
 590                    print 'Auto-merging', ren1.dstName
 591
 592                if not clean:
 593                    print 'CONFLICT (content): merge conflict in', ren1.dstName
 594                    cleanMerge = False
 595
 596                    if not cacheOnly:
 597                        updateFileExt(ren1.dstSha, ren1.dstMode, ren1.dstName,
 598                                      updateCache=True, updateWd=False)
 599                updateFile(clean, resSha, resMode, ren1.dstName)
 600        else:
 601            # Renamed in 1, maybe changed in 2
 602            if renamesA == renames1:
 603                stage = 3
 604            else:
 605                stage = 2
 606                
 607            srcShaOtherBranch  = ren1.srcCacheEntry.stages[stage].sha1
 608            srcModeOtherBranch = ren1.srcCacheEntry.stages[stage].mode
 609
 610            dstShaOtherBranch  = ren1.dstCacheEntry.stages[stage].sha1
 611            dstModeOtherBranch = ren1.dstCacheEntry.stages[stage].mode
 612
 613            tryMerge = False
 614            
 615            if ren1.dstName in currentDirectorySet:
 616                newPath = uniquePath(ren1.dstName, branchName1)
 617                print 'CONFLICT (rename/directory): Rename', \
 618                      fmtRename(ren1.srcName, ren1.dstName), 'in', branchName1,\
 619                      'directory', ren1.dstName, 'added in', branchName2
 620                print 'Renaming', ren1.srcName, 'to', newPath, 'instead'
 621                cleanMerge = False
 622                removeFile(False, ren1.dstName)
 623                updateFile(False, ren1.dstSha, ren1.dstMode, newPath)
 624            elif srcShaOtherBranch == None:
 625                print 'CONFLICT (rename/delete): Rename', \
 626                      fmtRename(ren1.srcName, ren1.dstName), 'in', \
 627                      branchName1, 'and deleted in', branchName2
 628                cleanMerge = False
 629                updateFile(False, ren1.dstSha, ren1.dstMode, ren1.dstName)
 630            elif dstShaOtherBranch:
 631                newPath = uniquePath(ren1.dstName, branchName2)
 632                print 'CONFLICT (rename/add): Rename', \
 633                      fmtRename(ren1.srcName, ren1.dstName), 'in', \
 634                      branchName1 + '.', ren1.dstName, 'added in', branchName2
 635                print 'Adding as', newPath, 'instead'
 636                updateFile(False, dstShaOtherBranch, dstModeOtherBranch, newPath)
 637                cleanMerge = False
 638                tryMerge = True
 639            elif renames2.getDst(ren1.dstName):
 640                dst2 = renames2.getDst(ren1.dstName)
 641                newPath1 = uniquePath(ren1.dstName, branchName1)
 642                newPath2 = uniquePath(dst2.dstName, branchName2)
 643                print 'CONFLICT (rename/rename): Rename', \
 644                      fmtRename(ren1.srcName, ren1.dstName), 'in', \
 645                      branchName1+'. Rename', \
 646                      fmtRename(dst2.srcName, dst2.dstName), 'in', branchName2
 647                print 'Renaming', ren1.srcName, 'to', newPath1, 'and', \
 648                      dst2.srcName, 'to', newPath2, 'instead'
 649                removeFile(False, ren1.dstName)
 650                updateFile(False, ren1.dstSha, ren1.dstMode, newPath1)
 651                updateFile(False, dst2.dstSha, dst2.dstMode, newPath2)
 652                dst2.processed = True
 653                cleanMerge = False
 654            else:
 655                tryMerge = True
 656
 657            if tryMerge:
 658                [resSha, resMode, clean, merge] = \
 659                         mergeFile(ren1.srcName, ren1.srcSha, ren1.srcMode,
 660                                   ren1.dstName, ren1.dstSha, ren1.dstMode,
 661                                   ren1.srcName, srcShaOtherBranch, srcModeOtherBranch,
 662                                   branchName1, branchName2)
 663
 664                if merge or not clean:
 665                    print 'Renaming', fmtRename(ren1.srcName, ren1.dstName)
 666
 667                if merge:
 668                    print 'Auto-merging', ren1.dstName
 669
 670                if not clean:
 671                    print 'CONFLICT (rename/modify): Merge conflict in', ren1.dstName
 672                    cleanMerge = False
 673
 674                    if not cacheOnly:
 675                        updateFileExt(ren1.dstSha, ren1.dstMode, ren1.dstName,
 676                                      updateCache=True, updateWd=False)
 677                updateFile(clean, resSha, resMode, ren1.dstName)
 678
 679    return cleanMerge
 680
 681# Per entry merge function
 682# ------------------------
 683
 684def processEntry(entry, branch1Name, branch2Name):
 685    '''Merge one cache entry.'''
 686
 687    debug('processing', entry.path, 'clean cache:', cacheOnly)
 688
 689    cleanMerge = True
 690
 691    path = entry.path
 692    oSha = entry.stages[1].sha1
 693    oMode = entry.stages[1].mode
 694    aSha = entry.stages[2].sha1
 695    aMode = entry.stages[2].mode
 696    bSha = entry.stages[3].sha1
 697    bMode = entry.stages[3].mode
 698
 699    assert(oSha == None or isSha(oSha))
 700    assert(aSha == None or isSha(aSha))
 701    assert(bSha == None or isSha(bSha))
 702
 703    assert(oMode == None or type(oMode) is int)
 704    assert(aMode == None or type(aMode) is int)
 705    assert(bMode == None or type(bMode) is int)
 706
 707    if (oSha and (not aSha or not bSha)):
 708    #
 709    # Case A: Deleted in one
 710    #
 711        if (not aSha     and not bSha) or \
 712           (aSha == oSha and not bSha) or \
 713           (not aSha     and bSha == oSha):
 714    # Deleted in both or deleted in one and unchanged in the other
 715            if aSha:
 716                print 'Removing', path
 717            removeFile(True, path)
 718        else:
 719    # Deleted in one and changed in the other
 720            cleanMerge = False
 721            if not aSha:
 722                print 'CONFLICT (delete/modify):', path, 'deleted in', \
 723                      branch1Name, 'and modified in', branch2Name + '.', \
 724                      'Version', branch2Name, 'of', path, 'left in tree.'
 725                mode = bMode
 726                sha = bSha
 727            else:
 728                print 'CONFLICT (modify/delete):', path, 'deleted in', \
 729                      branch2Name, 'and modified in', branch1Name + '.', \
 730                      'Version', branch1Name, 'of', path, 'left in tree.'
 731                mode = aMode
 732                sha = aSha
 733
 734            updateFile(False, sha, mode, path)
 735
 736    elif (not oSha and aSha     and not bSha) or \
 737         (not oSha and not aSha and bSha):
 738    #
 739    # Case B: Added in one.
 740    #
 741        if aSha:
 742            addBranch = branch1Name
 743            otherBranch = branch2Name
 744            mode = aMode
 745            sha = aSha
 746            conf = 'file/directory'
 747        else:
 748            addBranch = branch2Name
 749            otherBranch = branch1Name
 750            mode = bMode
 751            sha = bSha
 752            conf = 'directory/file'
 753    
 754        if path in currentDirectorySet:
 755            cleanMerge = False
 756            newPath = uniquePath(path, addBranch)
 757            print 'CONFLICT (' + conf + '):', \
 758                  'There is a directory with name', path, 'in', \
 759                  otherBranch + '. Adding', path, 'as', newPath
 760
 761            removeFile(False, path)
 762            updateFile(False, sha, mode, newPath)
 763        else:
 764            print 'Adding', path
 765            updateFile(True, sha, mode, path)
 766    
 767    elif not oSha and aSha and bSha:
 768    #
 769    # Case C: Added in both (check for same permissions).
 770    #
 771        if aSha == bSha:
 772            if aMode != bMode:
 773                cleanMerge = False
 774                print 'CONFLICT: File', path, \
 775                      'added identically in both branches, but permissions', \
 776                      'conflict', '0%o' % aMode, '->', '0%o' % bMode
 777                print 'CONFLICT: adding with permission:', '0%o' % aMode
 778
 779                updateFile(False, aSha, aMode, path)
 780            else:
 781                # This case is handled by git-read-tree
 782                assert(False)
 783        else:
 784            cleanMerge = False
 785            newPath1 = uniquePath(path, branch1Name)
 786            newPath2 = uniquePath(path, branch2Name)
 787            print 'CONFLICT (add/add): File', path, \
 788                  'added non-identically in both branches. Adding as', \
 789                  newPath1, 'and', newPath2, 'instead.'
 790            removeFile(False, path)
 791            updateFile(False, aSha, aMode, newPath1)
 792            updateFile(False, bSha, bMode, newPath2)
 793
 794    elif oSha and aSha and bSha:
 795    #
 796    # case D: Modified in both, but differently.
 797    #
 798        print 'Auto-merging', path
 799        [sha, mode, clean, dummy] = \
 800              mergeFile(path, oSha, oMode,
 801                        path, aSha, aMode,
 802                        path, bSha, bMode,
 803                        branch1Name, branch2Name)
 804        if clean:
 805            updateFile(True, sha, mode, path)
 806        else:
 807            cleanMerge = False
 808            print 'CONFLICT (content): Merge conflict in', path
 809
 810            if cacheOnly:
 811                updateFile(False, sha, mode, path)
 812            else:
 813                updateFileExt(aSha, aMode, path,
 814                              updateCache=True, updateWd=False)
 815                updateFileExt(sha, mode, path, updateCache=False, updateWd=True)
 816    else:
 817        die("ERROR: Fatal merge failure, shouldn't happen.")
 818
 819    return cleanMerge
 820
 821def usage():
 822    die('Usage:', sys.argv[0], ' <base>... -- <head> <remote>..')
 823
 824# main entry point as merge strategy module
 825# The first parameters up to -- are merge bases, and the rest are heads.
 826# This strategy module figures out merge bases itself, so we only
 827# get heads.
 828
 829if len(sys.argv) < 4:
 830    usage()
 831
 832for nextArg in xrange(1, len(sys.argv)):
 833    if sys.argv[nextArg] == '--':
 834        if len(sys.argv) != nextArg + 3:
 835            die('Not handling anything other than two heads merge.')
 836        try:
 837            h1 = firstBranch = sys.argv[nextArg + 1]
 838            h2 = secondBranch = sys.argv[nextArg + 2]
 839        except IndexError:
 840            usage()
 841        break
 842
 843print 'Merging', h1, 'with', h2
 844
 845try:
 846    h1 = runProgram(['git-rev-parse', '--verify', h1 + '^0']).rstrip()
 847    h2 = runProgram(['git-rev-parse', '--verify', h2 + '^0']).rstrip()
 848
 849    graph = buildGraph([h1, h2])
 850
 851    [dummy, clean] = merge(graph.shaMap[h1], graph.shaMap[h2],
 852                           firstBranch, secondBranch, graph)
 853
 854    print ''
 855except:
 856    if isinstance(sys.exc_info()[1], SystemExit):
 857        raise
 858    else:
 859        traceback.print_exc(None, sys.stderr)
 860        sys.exit(2)
 861
 862if clean:
 863    sys.exit(0)
 864else:
 865    sys.exit(1)