Make networking commands to work from a subdirectory.
[git] / 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', 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 removeFile(clean, path):
284     updateCache = cacheOnly or clean
285     updateWd = not cacheOnly
286
287     if updateCache:
288         runProgram(['git-update-index', '--force-remove', '--', path])
289
290     if updateWd:
291         try:
292             os.unlink(path)
293         except OSError, e:
294             if e.errno != errno.ENOENT and e.errno != errno.EISDIR:
295                 raise
296         try:
297             os.removedirs(os.path.dirname(path))
298         except OSError:
299             pass
300
301 def uniquePath(path, branch):
302     def fileExists(path):
303         try:
304             os.lstat(path)
305             return True
306         except OSError, e:
307             if e.errno == errno.ENOENT:
308                 return False
309             else:
310                 raise
311
312     branch = branch.replace('/', '_')
313     newPath = path + '~' + branch
314     suffix = 0
315     while newPath in currentFileSet or \
316           newPath in currentDirectorySet  or \
317           fileExists(newPath):
318         suffix += 1
319         newPath = path + '~' + branch + '_' + str(suffix)
320     currentFileSet.add(newPath)
321     return newPath
322
323 # Cache entry management
324 # ----------------------
325
326 class CacheEntry:
327     def __init__(self, path):
328         class Stage:
329             def __init__(self):
330                 self.sha1 = None
331                 self.mode = None
332
333             # Used for debugging only
334             def __str__(self):
335                 if self.mode != None:
336                     m = '0%o' % self.mode
337                 else:
338                     m = 'None'
339
340                 if self.sha1:
341                     sha1 = self.sha1
342                 else:
343                     sha1 = 'None'
344                 return 'sha1: ' + sha1 + ' mode: ' + m
345         
346         self.stages = [Stage(), Stage(), Stage(), Stage()]
347         self.path = path
348         self.processed = False
349
350     def __str__(self):
351         return 'path: ' + self.path + ' stages: ' + repr([str(x) for x in self.stages])
352
353 class CacheEntryContainer:
354     def __init__(self):
355         self.entries = {}
356
357     def add(self, entry):
358         self.entries[entry.path] = entry
359
360     def get(self, path):
361         return self.entries.get(path)
362
363     def __iter__(self):
364         return self.entries.itervalues()
365     
366 unmergedRE = re.compile(r'^([0-7]+) ([0-9a-f]{40}) ([1-3])\t(.*)$', re.S)
367 def unmergedCacheEntries():
368     '''Create a dictionary mapping file names to CacheEntry
369     objects. The dictionary contains one entry for every path with a
370     non-zero stage entry.'''
371
372     lines = runProgram(['git-ls-files', '-z', '--unmerged']).split('\0')
373     lines.pop()
374
375     res = CacheEntryContainer()
376     for l in lines:
377         m = unmergedRE.match(l)
378         if m:
379             mode = int(m.group(1), 8)
380             sha1 = m.group(2)
381             stage = int(m.group(3))
382             path = m.group(4)
383
384             e = res.get(path)
385             if not e:
386                 e = CacheEntry(path)
387                 res.add(e)
388
389             e.stages[stage].mode = mode
390             e.stages[stage].sha1 = sha1
391         else:
392             die('Error: Merge program failed: Unexpected output from',
393                 'git-ls-files:', l)
394     return res
395
396 lsTreeRE = re.compile(r'^([0-7]+) (\S+) ([0-9a-f]{40})\t(.*)\n$', re.S)
397 def getCacheEntry(path, origTree, aTree, bTree):
398     '''Returns a CacheEntry object which doesn't have to correspond to
399     a real cache entry in Git's index.'''
400     
401     def parse(out):
402         if out == '':
403             return [None, None]
404         else:
405             m = lsTreeRE.match(out)
406             if not m:
407                 die('Unexpected output from git-ls-tree:', out)
408             elif m.group(2) == 'blob':
409                 return [m.group(3), int(m.group(1), 8)]
410             else:
411                 return [None, None]
412
413     res = CacheEntry(path)
414
415     [oSha, oMode] = parse(runProgram(['git-ls-tree', origTree, '--', path]))
416     [aSha, aMode] = parse(runProgram(['git-ls-tree', aTree, '--', path]))
417     [bSha, bMode] = parse(runProgram(['git-ls-tree', bTree, '--', path]))
418
419     res.stages[1].sha1 = oSha
420     res.stages[1].mode = oMode
421     res.stages[2].sha1 = aSha
422     res.stages[2].mode = aMode
423     res.stages[3].sha1 = bSha
424     res.stages[3].mode = bMode
425
426     return res
427
428 # Rename detection and handling
429 # -----------------------------
430
431 class RenameEntry:
432     def __init__(self,
433                  src, srcSha, srcMode, srcCacheEntry,
434                  dst, dstSha, dstMode, dstCacheEntry,
435                  score):
436         self.srcName = src
437         self.srcSha = srcSha
438         self.srcMode = srcMode
439         self.srcCacheEntry = srcCacheEntry
440         self.dstName = dst
441         self.dstSha = dstSha
442         self.dstMode = dstMode
443         self.dstCacheEntry = dstCacheEntry
444         self.score = score
445
446         self.processed = False
447
448 class RenameEntryContainer:
449     def __init__(self):
450         self.entriesSrc = {}
451         self.entriesDst = {}
452
453     def add(self, entry):
454         self.entriesSrc[entry.srcName] = entry
455         self.entriesDst[entry.dstName] = entry
456
457     def getSrc(self, path):
458         return self.entriesSrc.get(path)
459
460     def getDst(self, path):
461         return self.entriesDst.get(path)
462
463     def __iter__(self):
464         return self.entriesSrc.itervalues()
465
466 parseDiffRenamesRE = re.compile('^:([0-7]+) ([0-7]+) ([0-9a-f]{40}) ([0-9a-f]{40}) R([0-9]*)$')
467 def getRenames(tree, oTree, aTree, bTree, cacheEntries):
468     '''Get information of all renames which occured between 'oTree' and
469     'tree'. We need the three trees in the merge ('oTree', 'aTree' and
470     'bTree') to be able to associate the correct cache entries with
471     the rename information. 'tree' is always equal to either aTree or bTree.'''
472
473     assert(tree == aTree or tree == bTree)
474     inp = runProgram(['git-diff-tree', '-M', '--diff-filter=R', '-r',
475                       '-z', oTree, tree])
476
477     ret = RenameEntryContainer()
478     try:
479         recs = inp.split("\0")
480         recs.pop() # remove last entry (which is '')
481         it = recs.__iter__()
482         while True:
483             rec = it.next()
484             m = parseDiffRenamesRE.match(rec)
485
486             if not m:
487                 die('Unexpected output from git-diff-tree:', rec)
488
489             srcMode = int(m.group(1), 8)
490             dstMode = int(m.group(2), 8)
491             srcSha = m.group(3)
492             dstSha = m.group(4)
493             score = m.group(5)
494             src = it.next()
495             dst = it.next()
496
497             srcCacheEntry = cacheEntries.get(src)
498             if not srcCacheEntry:
499                 srcCacheEntry = getCacheEntry(src, oTree, aTree, bTree)
500                 cacheEntries.add(srcCacheEntry)
501
502             dstCacheEntry = cacheEntries.get(dst)
503             if not dstCacheEntry:
504                 dstCacheEntry = getCacheEntry(dst, oTree, aTree, bTree)
505                 cacheEntries.add(dstCacheEntry)
506
507             ret.add(RenameEntry(src, srcSha, srcMode, srcCacheEntry,
508                                 dst, dstSha, dstMode, dstCacheEntry,
509                                 score))
510     except StopIteration:
511         pass
512     return ret
513
514 def fmtRename(src, dst):
515     srcPath = src.split('/')
516     dstPath = dst.split('/')
517     path = []
518     endIndex = min(len(srcPath), len(dstPath)) - 1
519     for x in range(0, endIndex):
520         if srcPath[x] == dstPath[x]:
521             path.append(srcPath[x])
522         else:
523             endIndex = x
524             break
525
526     if len(path) > 0:
527         return '/'.join(path) + \
528                '/{' + '/'.join(srcPath[endIndex:]) + ' => ' + \
529                '/'.join(dstPath[endIndex:]) + '}'
530     else:
531         return src + ' => ' + dst
532
533 def processRenames(renamesA, renamesB, branchNameA, branchNameB):
534     srcNames = Set()
535     for x in renamesA:
536         srcNames.add(x.srcName)
537     for x in renamesB:
538         srcNames.add(x.srcName)
539
540     cleanMerge = True
541     for path in srcNames:
542         if renamesA.getSrc(path):
543             renames1 = renamesA
544             renames2 = renamesB
545             branchName1 = branchNameA
546             branchName2 = branchNameB
547         else:
548             renames1 = renamesB
549             renames2 = renamesA
550             branchName1 = branchNameB
551             branchName2 = branchNameA
552         
553         ren1 = renames1.getSrc(path)
554         ren2 = renames2.getSrc(path)
555
556         ren1.dstCacheEntry.processed = True
557         ren1.srcCacheEntry.processed = True
558
559         if ren1.processed:
560             continue
561
562         ren1.processed = True
563         removeFile(True, ren1.srcName)
564         if ren2:
565             # Renamed in 1 and renamed in 2
566             assert(ren1.srcName == ren2.srcName)
567             ren2.dstCacheEntry.processed = True
568             ren2.processed = True
569
570             if ren1.dstName != ren2.dstName:
571                 output('CONFLICT (rename/rename): Rename',
572                        fmtRename(path, ren1.dstName), 'in branch', branchName1,
573                        'rename', fmtRename(path, ren2.dstName), 'in',
574                        branchName2)
575                 cleanMerge = False
576
577                 if ren1.dstName in currentDirectorySet:
578                     dstName1 = uniquePath(ren1.dstName, branchName1)
579                     output(ren1.dstName, 'is a directory in', branchName2,
580                            'adding as', dstName1, 'instead.')
581                     removeFile(False, ren1.dstName)
582                 else:
583                     dstName1 = ren1.dstName
584
585                 if ren2.dstName in currentDirectorySet:
586                     dstName2 = uniquePath(ren2.dstName, branchName2)
587                     output(ren2.dstName, 'is a directory in', branchName1,
588                            'adding as', dstName2, 'instead.')
589                     removeFile(False, ren2.dstName)
590                 else:
591                     dstName2 = ren1.dstName
592
593                 updateFile(False, ren1.dstSha, ren1.dstMode, dstName1)
594                 updateFile(False, ren2.dstSha, ren2.dstMode, dstName2)
595             else:
596                 [resSha, resMode, clean, merge] = \
597                          mergeFile(ren1.srcName, ren1.srcSha, ren1.srcMode,
598                                    ren1.dstName, ren1.dstSha, ren1.dstMode,
599                                    ren2.dstName, ren2.dstSha, ren2.dstMode,
600                                    branchName1, branchName2)
601
602                 if merge or not clean:
603                     output('Renaming', fmtRename(path, ren1.dstName))
604
605                 if merge:
606                     output('Auto-merging', ren1.dstName)
607
608                 if not clean:
609                     output('CONFLICT (content): merge conflict in',
610                            ren1.dstName)
611                     cleanMerge = False
612
613                     if not cacheOnly:
614                         updateFileExt(ren1.dstSha, ren1.dstMode, ren1.dstName,
615                                       updateCache=True, updateWd=False)
616                 updateFile(clean, resSha, resMode, ren1.dstName)
617         else:
618             # Renamed in 1, maybe changed in 2
619             if renamesA == renames1:
620                 stage = 3
621             else:
622                 stage = 2
623                 
624             srcShaOtherBranch  = ren1.srcCacheEntry.stages[stage].sha1
625             srcModeOtherBranch = ren1.srcCacheEntry.stages[stage].mode
626
627             dstShaOtherBranch  = ren1.dstCacheEntry.stages[stage].sha1
628             dstModeOtherBranch = ren1.dstCacheEntry.stages[stage].mode
629
630             tryMerge = False
631             
632             if ren1.dstName in currentDirectorySet:
633                 newPath = uniquePath(ren1.dstName, branchName1)
634                 output('CONFLICT (rename/directory): Rename',
635                        fmtRename(ren1.srcName, ren1.dstName), 'in', branchName1,
636                        'directory', ren1.dstName, 'added in', branchName2)
637                 output('Renaming', ren1.srcName, 'to', newPath, 'instead')
638                 cleanMerge = False
639                 removeFile(False, ren1.dstName)
640                 updateFile(False, ren1.dstSha, ren1.dstMode, newPath)
641             elif srcShaOtherBranch == None:
642                 output('CONFLICT (rename/delete): Rename',
643                        fmtRename(ren1.srcName, ren1.dstName), 'in',
644                        branchName1, 'and deleted in', branchName2)
645                 cleanMerge = False
646                 updateFile(False, ren1.dstSha, ren1.dstMode, ren1.dstName)
647             elif dstShaOtherBranch:
648                 newPath = uniquePath(ren1.dstName, branchName2)
649                 output('CONFLICT (rename/add): Rename',
650                        fmtRename(ren1.srcName, ren1.dstName), 'in',
651                        branchName1 + '.', ren1.dstName, 'added in', branchName2)
652                 output('Adding as', newPath, 'instead')
653                 updateFile(False, dstShaOtherBranch, dstModeOtherBranch, newPath)
654                 cleanMerge = False
655                 tryMerge = True
656             elif renames2.getDst(ren1.dstName):
657                 dst2 = renames2.getDst(ren1.dstName)
658                 newPath1 = uniquePath(ren1.dstName, branchName1)
659                 newPath2 = uniquePath(dst2.dstName, branchName2)
660                 output('CONFLICT (rename/rename): Rename',
661                        fmtRename(ren1.srcName, ren1.dstName), 'in',
662                        branchName1+'. Rename',
663                        fmtRename(dst2.srcName, dst2.dstName), 'in', branchName2)
664                 output('Renaming', ren1.srcName, 'to', newPath1, 'and',
665                        dst2.srcName, 'to', newPath2, 'instead')
666                 removeFile(False, ren1.dstName)
667                 updateFile(False, ren1.dstSha, ren1.dstMode, newPath1)
668                 updateFile(False, dst2.dstSha, dst2.dstMode, newPath2)
669                 dst2.processed = True
670                 cleanMerge = False
671             else:
672                 tryMerge = True
673
674             if tryMerge:
675                 [resSha, resMode, clean, merge] = \
676                          mergeFile(ren1.srcName, ren1.srcSha, ren1.srcMode,
677                                    ren1.dstName, ren1.dstSha, ren1.dstMode,
678                                    ren1.srcName, srcShaOtherBranch, srcModeOtherBranch,
679                                    branchName1, branchName2)
680
681                 if merge or not clean:
682                     output('Renaming', fmtRename(ren1.srcName, ren1.dstName))
683
684                 if merge:
685                     output('Auto-merging', ren1.dstName)
686
687                 if not clean:
688                     output('CONFLICT (rename/modify): Merge conflict in',
689                            ren1.dstName)
690                     cleanMerge = False
691
692                     if not cacheOnly:
693                         updateFileExt(ren1.dstSha, ren1.dstMode, ren1.dstName,
694                                       updateCache=True, updateWd=False)
695                 updateFile(clean, resSha, resMode, ren1.dstName)
696
697     return cleanMerge
698
699 # Per entry merge function
700 # ------------------------
701
702 def processEntry(entry, branch1Name, branch2Name):
703     '''Merge one cache entry.'''
704
705     debug('processing', entry.path, 'clean cache:', cacheOnly)
706
707     cleanMerge = True
708
709     path = entry.path
710     oSha = entry.stages[1].sha1
711     oMode = entry.stages[1].mode
712     aSha = entry.stages[2].sha1
713     aMode = entry.stages[2].mode
714     bSha = entry.stages[3].sha1
715     bMode = entry.stages[3].mode
716
717     assert(oSha == None or isSha(oSha))
718     assert(aSha == None or isSha(aSha))
719     assert(bSha == None or isSha(bSha))
720
721     assert(oMode == None or type(oMode) is int)
722     assert(aMode == None or type(aMode) is int)
723     assert(bMode == None or type(bMode) is int)
724
725     if (oSha and (not aSha or not bSha)):
726     #
727     # Case A: Deleted in one
728     #
729         if (not aSha     and not bSha) or \
730            (aSha == oSha and not bSha) or \
731            (not aSha     and bSha == oSha):
732     # Deleted in both or deleted in one and unchanged in the other
733             if aSha:
734                 output('Removing', path)
735             removeFile(True, path)
736         else:
737     # Deleted in one and changed in the other
738             cleanMerge = False
739             if not aSha:
740                 output('CONFLICT (delete/modify):', path, 'deleted in',
741                        branch1Name, 'and modified in', branch2Name + '.',
742                        'Version', branch2Name, 'of', path, 'left in tree.')
743                 mode = bMode
744                 sha = bSha
745             else:
746                 output('CONFLICT (modify/delete):', path, 'deleted in',
747                        branch2Name, 'and modified in', branch1Name + '.',
748                        'Version', branch1Name, 'of', path, 'left in tree.')
749                 mode = aMode
750                 sha = aSha
751
752             updateFile(False, sha, mode, path)
753
754     elif (not oSha and aSha     and not bSha) or \
755          (not oSha and not aSha and bSha):
756     #
757     # Case B: Added in one.
758     #
759         if aSha:
760             addBranch = branch1Name
761             otherBranch = branch2Name
762             mode = aMode
763             sha = aSha
764             conf = 'file/directory'
765         else:
766             addBranch = branch2Name
767             otherBranch = branch1Name
768             mode = bMode
769             sha = bSha
770             conf = 'directory/file'
771     
772         if path in currentDirectorySet:
773             cleanMerge = False
774             newPath = uniquePath(path, addBranch)
775             output('CONFLICT (' + conf + '):',
776                    'There is a directory with name', path, 'in',
777                    otherBranch + '. Adding', path, 'as', newPath)
778
779             removeFile(False, path)
780             updateFile(False, sha, mode, newPath)
781         else:
782             output('Adding', path)
783             updateFile(True, sha, mode, path)
784     
785     elif not oSha and aSha and bSha:
786     #
787     # Case C: Added in both (check for same permissions).
788     #
789         if aSha == bSha:
790             if aMode != bMode:
791                 cleanMerge = False
792                 output('CONFLICT: File', path,
793                        'added identically in both branches, but permissions',
794                        'conflict', '0%o' % aMode, '->', '0%o' % bMode)
795                 output('CONFLICT: adding with permission:', '0%o' % aMode)
796
797                 updateFile(False, aSha, aMode, path)
798             else:
799                 # This case is handled by git-read-tree
800                 assert(False)
801         else:
802             cleanMerge = False
803             newPath1 = uniquePath(path, branch1Name)
804             newPath2 = uniquePath(path, branch2Name)
805             output('CONFLICT (add/add): File', path,
806                    'added non-identically in both branches. Adding as',
807                    newPath1, 'and', newPath2, 'instead.')
808             removeFile(False, path)
809             updateFile(False, aSha, aMode, newPath1)
810             updateFile(False, bSha, bMode, newPath2)
811
812     elif oSha and aSha and bSha:
813     #
814     # case D: Modified in both, but differently.
815     #
816         output('Auto-merging', path)
817         [sha, mode, clean, dummy] = \
818               mergeFile(path, oSha, oMode,
819                         path, aSha, aMode,
820                         path, bSha, bMode,
821                         branch1Name, branch2Name)
822         if clean:
823             updateFile(True, sha, mode, path)
824         else:
825             cleanMerge = False
826             output('CONFLICT (content): Merge conflict in', path)
827
828             if cacheOnly:
829                 updateFile(False, sha, mode, path)
830             else:
831                 updateFileExt(aSha, aMode, path,
832                               updateCache=True, updateWd=False)
833                 updateFileExt(sha, mode, path, updateCache=False, updateWd=True)
834     else:
835         die("ERROR: Fatal merge failure, shouldn't happen.")
836
837     return cleanMerge
838
839 def usage():
840     die('Usage:', sys.argv[0], ' <base>... -- <head> <remote>..')
841
842 # main entry point as merge strategy module
843 # The first parameters up to -- are merge bases, and the rest are heads.
844 # This strategy module figures out merge bases itself, so we only
845 # get heads.
846
847 if len(sys.argv) < 4:
848     usage()
849
850 for nextArg in xrange(1, len(sys.argv)):
851     if sys.argv[nextArg] == '--':
852         if len(sys.argv) != nextArg + 3:
853             die('Not handling anything other than two heads merge.')
854         try:
855             h1 = firstBranch = sys.argv[nextArg + 1]
856             h2 = secondBranch = sys.argv[nextArg + 2]
857         except IndexError:
858             usage()
859         break
860
861 print 'Merging', h1, 'with', h2
862
863 try:
864     h1 = runProgram(['git-rev-parse', '--verify', h1 + '^0']).rstrip()
865     h2 = runProgram(['git-rev-parse', '--verify', h2 + '^0']).rstrip()
866
867     graph = buildGraph([h1, h2])
868
869     [dummy, clean] = merge(graph.shaMap[h1], graph.shaMap[h2],
870                            firstBranch, secondBranch, graph)
871
872     print ''
873 except:
874     if isinstance(sys.exc_info()[1], SystemExit):
875         raise
876     else:
877         traceback.print_exc(None, sys.stderr)
878         sys.exit(2)
879
880 if clean:
881     sys.exit(0)
882 else:
883     sys.exit(1)