git-merge-recursive.py

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