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