← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge3.py

  • Committer: Martin Pool
  • Date: 2008-06-11 02:36:40 UTC
  • mfrom: (3490 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3492.
  • Revision ID: mbp@sourcefrog.net-20080611023640-db0lqd75yueksdw7
Merge news

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge3.py
36
36
    >>> intersect((0, 9), (7, 15))
37
37
    (7, 9)
38
38
    """
39
 
    assert ra[0] <= ra[1]
40
 
    assert rb[0] <= rb[1]
 
39
    # preconditions: (ra[0] <= ra[1]) and (rb[0] <= rb[1])
41
40
    
42
41
    sa = max(ra[0], rb[0])
43
42
    sb = min(ra[1], rb[1])
222
221
        iz = ia = ib = 0
223
222
        
224
223
        for zmatch, zend, amatch, aend, bmatch, bend in self.find_sync_regions():
225
 
            #print 'match base [%d:%d]' % (zmatch, zend)
226
 
            
227
224
            matchlen = zend - zmatch
228
 
            assert matchlen >= 0
229
 
            assert matchlen == (aend - amatch)
230
 
            assert matchlen == (bend - bmatch)
231
 
            
 
225
            # invariants:
 
226
            #   matchlen >= 0
 
227
            #   matchlen == (aend - amatch)
 
228
            #   matchlen == (bend - bmatch)
232
229
            len_a = amatch - ia
233
230
            len_b = bmatch - ib
234
231
            len_base = zmatch - iz
235
 
            assert len_a >= 0
236
 
            assert len_b >= 0
237
 
            assert len_base >= 0
 
232
            # invariants:
 
233
            # assert len_a >= 0
 
234
            # assert len_b >= 0
 
235
            # assert len_base >= 0
238
236
 
239
237
            #print 'unmatched a=%d, b=%d' % (len_a, len_b)
240
238
 
273
271
            # that's OK, we can just skip it.
274
272
 
275
273
            if matchlen > 0:
276
 
                assert ia == amatch
277
 
                assert ib == bmatch
278
 
                assert iz == zmatch
 
274
                # invariants:
 
275
                # assert ia == amatch
 
276
                # assert ib == bmatch
 
277
                # assert iz == zmatch
279
278
                
280
279
                yield 'unchanged', zmatch, zend
281
280
                iz = zend
389
388
 
390
389
                # found a match of base[i[0], i[1]]; this may be less than
391
390
                # the region that matches in either one
392
 
                assert intlen <= alen
393
 
                assert intlen <= blen
394
 
                assert abase <= intbase
395
 
                assert bbase <= intbase
 
391
                # assert intlen <= alen
 
392
                # assert intlen <= blen
 
393
                # assert abase <= intbase
 
394
                # assert bbase <= intbase
396
395
 
397
396
                asub = amatch + (intbase - abase)
398
397
                bsub = bmatch + (intbase - bbase)
399
398
                aend = asub + intlen
400
399
                bend = bsub + intlen
401
400
 
402
 
                assert self.base[intbase:intend] == self.a[asub:aend], \
403
 
                       (self.base[intbase:intend], self.a[asub:aend])
404
 
 
405
 
                assert self.base[intbase:intend] == self.b[bsub:bend]
 
401
                # assert self.base[intbase:intend] == self.a[asub:aend], \
 
402
                #       (self.base[intbase:intend], self.a[asub:aend])
 
403
                # assert self.base[intbase:intend] == self.b[bsub:bend]
406
404
 
407
405
                sl.append((intbase, intend,
408
406
                           asub, aend,
409
407
                           bsub, bend))
410
 
 
411
408
            # advance whichever one ends first in the base text
412
409
            if (abase + alen) < (bbase + blen):
413
410
                ia += 1