← 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: 2005-07-06 01:04:08 UTC
  • Revision ID: mbp@sourcefrog.net-20050706010408-6a5f429ee8eb3824
- Merge3.find_sync_regions() - avoid problems with iters on python2.3 by 
  just stepping through arrays; also make this return a list rather than 
  being a generator.

  Thanks very much to John for the report and help debugging.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge3.py
197
197
        iz = ia = ib = 0
198
198
        
199
199
        for zmatch, zend, amatch, aend, bmatch, bend in self.find_sync_regions():
 
200
            #print 'match base [%d:%d]' % (zmatch, zend)
 
201
            
200
202
            matchlen = zend - zmatch
201
203
            assert matchlen >= 0
202
204
            assert matchlen == (aend - amatch)
209
211
            assert len_b >= 0
210
212
            assert len_base >= 0
211
213
 
 
214
            #print 'unmatched a=%d, b=%d' % (len_a, len_b)
 
215
 
212
216
            if len_a or len_b:
213
217
                lines_base = self.base[iz:zmatch]
214
218
                lines_a = self.a[ia:amatch]
260
264
        always a zero-length sync region at the end of all the files.
261
265
        """
262
266
        from difflib import SequenceMatcher
263
 
        aiter = iter(SequenceMatcher(None, self.base, self.a).get_matching_blocks())
264
 
        biter = iter(SequenceMatcher(None, self.base, self.b).get_matching_blocks())
265
 
 
266
 
        abase, amatch, alen = aiter.next()
267
 
        bbase, bmatch, blen = biter.next()
268
 
 
269
 
        while aiter and biter:
 
267
 
 
268
        ia = ib = 0
 
269
        amatches = SequenceMatcher(None, self.base, self.a).get_matching_blocks()
 
270
        bmatches = SequenceMatcher(None, self.base, self.b).get_matching_blocks()
 
271
        len_a = len(amatches)
 
272
        len_b = len(bmatches)
 
273
 
 
274
        sl = []
 
275
 
 
276
        while ia < len_a and ib < len_b:
 
277
            abase, amatch, alen = amatches[ia]
 
278
            bbase, bmatch, blen = bmatches[ib]
 
279
 
270
280
            # there is an unconflicted block at i; how long does it
271
281
            # extend?  until whichever one ends earlier.
272
282
            i = intersect((abase, abase+alen), (bbase, bbase+blen))
289
299
 
290
300
                assert self.base[intbase:intend] == self.a[asub:aend], \
291
301
                       (self.base[intbase:intend], self.a[asub:aend])
292
 
                
 
302
 
293
303
                assert self.base[intbase:intend] == self.b[bsub:bend]
294
304
 
295
 
                yield (intbase, intend,
296
 
                       asub, aend,
297
 
                       bsub, bend)
 
305
                sl.append((intbase, intend,
 
306
                           asub, aend,
 
307
                           bsub, bend))
298
308
 
299
309
            # advance whichever one ends first in the base text
300
310
            if (abase + alen) < (bbase + blen):
301
 
                abase, amatch, alen = aiter.next()
 
311
                ia += 1
302
312
            else:
303
 
                bbase, bmatch, blen = biter.next()
304
 
 
 
313
                ib += 1
 
314
            
305
315
        intbase = len(self.base)
306
316
        abase = len(self.a)
307
317
        bbase = len(self.b)
308
 
        yield (intbase, intbase, abase, abase, bbase, bbase)
 
318
        sl.append((intbase, intbase, abase, abase, bbase, bbase))
 
319
 
 
320
        return sl
309
321
 
310
322
 
311
323
 
350
362
 
351
363
    m3 = Merge3(base, a, b)
352
364
 
 
365
    #for sr in m3.find_sync_regions():
 
366
    #    print sr
 
367
 
353
368
    # sys.stdout.writelines(m3.merge_lines(name_a=argv[1], name_b=argv[3]))
354
369
    sys.stdout.writelines(m3.merge_annotated())
355
370