~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-06-12 02:17:42 UTC
  • mfrom: (2521.1.1 56322)
  • Revision ID: pqm@pqm.ubuntu.com-20070612021742-uetsy3g747iq3xkk
mergeĀ initĀ --create-prefix

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
54
54
from itertools import izip
55
55
import re
56
56
 
 
57
from bzrlib import (
 
58
    registry,
 
59
    symbol_versioning,
 
60
    )
57
61
import bzrlib.errors as errors
 
62
from bzrlib.symbol_versioning import (
 
63
    deprecated_method,
 
64
    zero_eleven,
 
65
    zero_seventeen,
 
66
    )
58
67
from bzrlib.trace import mutter
59
 
from bzrlib.tsort import merge_sort
 
68
from bzrlib.tsort import (
 
69
    merge_sort,
 
70
    topo_sort,
 
71
    )
60
72
 
61
73
 
62
74
def find_touching_revisions(branch, file_id):
120
132
             direction='reverse',
121
133
             start_revision=None,
122
134
             end_revision=None,
123
 
             search=None):
 
135
             search=None,
 
136
             limit=None):
124
137
    """Write out human-readable log of commits to this branch.
125
138
 
126
139
    lf
142
155
 
143
156
    end_revision
144
157
        If not None, only show revisions <= end_revision
 
158
 
 
159
    search
 
160
        If not None, only show revisions with matching commit messages
 
161
 
 
162
    limit
 
163
        If not None or 0, only show limit revisions
145
164
    """
146
165
    branch.lock_read()
147
166
    try:
 
167
        if getattr(lf, 'begin_log', None):
 
168
            lf.begin_log()
 
169
 
148
170
        _show_log(branch, lf, specific_fileid, verbose, direction,
149
 
                  start_revision, end_revision, search)
 
171
                  start_revision, end_revision, search, limit)
 
172
 
 
173
        if getattr(lf, 'end_log', None):
 
174
            lf.end_log()
150
175
    finally:
151
176
        branch.unlock()
152
 
    
 
177
 
153
178
def _show_log(branch,
154
179
             lf,
155
180
             specific_fileid=None,
157
182
             direction='reverse',
158
183
             start_revision=None,
159
184
             end_revision=None,
160
 
             search=None):
 
185
             search=None,
 
186
             limit=None):
161
187
    """Worker function for show_log - see show_log."""
162
188
    from bzrlib.osutils import format_date
163
189
    from bzrlib.errors import BzrCheckError
202
228
        mainline_revs.insert(0, None)
203
229
    else:
204
230
        mainline_revs.insert(0, which_revs[start_revision-2][1])
205
 
    if getattr(lf, 'show_merge', None) is not None:
206
 
        include_merges = True 
207
 
    else:
208
 
        include_merges = False 
209
 
    view_revisions = list(get_view_revisions(mainline_revs, rev_nos, branch,
210
 
                          direction, include_merges=include_merges))
 
231
    legacy_lf = getattr(lf, 'log_revision', None) is None
 
232
    if legacy_lf:
 
233
        # pre-0.17 formatters use show for mainline revisions.
 
234
        # how should we show merged revisions ?
 
235
        #   pre-0.11 api: show_merge
 
236
        #   0.11-0.16 api: show_merge_revno
 
237
        show_merge_revno = getattr(lf, 'show_merge_revno', None)
 
238
        show_merge = getattr(lf, 'show_merge', None)
 
239
        if show_merge is None and show_merge_revno is None:
 
240
            # no merged-revno support
 
241
            generate_merge_revisions = False
 
242
        else:
 
243
            generate_merge_revisions = True
 
244
        # tell developers to update their code
 
245
        symbol_versioning.warn('LogFormatters should provide log_revision '
 
246
            'instead of show and show_merge_revno since bzr 0.17.',
 
247
            DeprecationWarning, stacklevel=3)
 
248
    else:
 
249
        generate_merge_revisions = getattr(lf, 'supports_merge_revisions', 
 
250
                                           False)
 
251
    view_revs_iter = get_view_revisions(mainline_revs, rev_nos, branch,
 
252
                          direction, include_merges=generate_merge_revisions)
 
253
    if specific_fileid:
 
254
        view_revisions = _get_revisions_touching_file_id(branch,
 
255
                                                         specific_fileid,
 
256
                                                         mainline_revs,
 
257
                                                         view_revs_iter)
 
258
    else:
 
259
        view_revisions = list(view_revs_iter)
 
260
 
 
261
    rev_tag_dict = {}
 
262
    generate_tags = getattr(lf, 'supports_tags', False)
 
263
    if generate_tags:
 
264
        if branch.supports_tags():
 
265
            rev_tag_dict = branch.tags.get_reverse_tag_dict()
 
266
 
 
267
    generate_delta = verbose and getattr(lf, 'supports_delta', False)
211
268
 
212
269
    def iter_revisions():
213
270
        # r = revision, n = revno, d = merge depth
218
275
        while revision_ids:
219
276
            cur_deltas = {}
220
277
            revisions = repository.get_revisions(revision_ids[:num])
221
 
            if verbose or specific_fileid:
 
278
            if generate_delta:
222
279
                delta_revisions = [r for r in revisions if
223
280
                                   r.revision_id in zeros]
224
281
                deltas = repository.get_deltas_for_revisions(delta_revisions)
226
283
                                        delta_revisions), deltas))
227
284
            for revision in revisions:
228
285
                # The delta value will be None unless
229
 
                # 1. verbose or specific_fileid is specified, and
 
286
                # 1. verbose is specified, and
230
287
                # 2. the revision is a mainline revision
231
288
                yield revision, cur_deltas.get(revision.revision_id)
232
289
            revision_ids  = revision_ids[num:]
233
 
            num = int(num * 1.5)
234
 
            
 
290
            num = min(int(num * 1.5), 200)
 
291
 
235
292
    # now we just print all the revisions
 
293
    log_count = 0
236
294
    for ((rev_id, revno, merge_depth), (rev, delta)) in \
237
295
         izip(view_revisions, iter_revisions()):
238
296
 
240
298
            if not searchRE.search(rev.message):
241
299
                continue
242
300
 
243
 
        if merge_depth == 0:
244
 
            # a mainline revision.
245
 
                
246
 
            if specific_fileid:
247
 
                if not delta.touches_file_id(specific_fileid):
248
 
                    continue
249
 
    
250
 
            if not verbose:
251
 
                # although we calculated it, throw it away without display
252
 
                delta = None
253
 
 
254
 
            lf.show(revno, rev, delta)
255
 
        else:
256
 
            lf.show_merge(rev, merge_depth)
 
301
        if not legacy_lf:
 
302
            lr = LogRevision(rev, revno, merge_depth, delta,
 
303
                             rev_tag_dict.get(rev_id))
 
304
            lf.log_revision(lr)
 
305
        else:
 
306
            # support for legacy (pre-0.17) LogFormatters
 
307
            if merge_depth == 0:
 
308
                if generate_tags:
 
309
                    lf.show(revno, rev, delta, rev_tag_dict.get(rev_id))
 
310
                else:
 
311
                    lf.show(revno, rev, delta)
 
312
            else:
 
313
                if show_merge_revno is None:
 
314
                    lf.show_merge(rev, merge_depth)
 
315
                else:
 
316
                    if generate_tags:
 
317
                        lf.show_merge_revno(rev, merge_depth, revno,
 
318
                                            rev_tag_dict.get(rev_id))
 
319
                    else:
 
320
                        lf.show_merge_revno(rev, merge_depth, revno)
 
321
        if limit:
 
322
            log_count += 1
 
323
            if log_count >= limit:
 
324
                break
 
325
 
 
326
 
 
327
def _get_revisions_touching_file_id(branch, file_id, mainline_revisions,
 
328
                                    view_revs_iter):
 
329
    """Return the list of revision ids which touch a given file id.
 
330
 
 
331
    This includes the revisions which directly change the file id,
 
332
    and the revisions which merge these changes. So if the
 
333
    revision graph is::
 
334
        A
 
335
        |\
 
336
        B C
 
337
        |/
 
338
        D
 
339
 
 
340
    And 'C' changes a file, then both C and D will be returned.
 
341
 
 
342
    This will also can be restricted based on a subset of the mainline.
 
343
 
 
344
    :return: A list of (revision_id, dotted_revno, merge_depth) tuples.
 
345
    """
 
346
    # find all the revisions that change the specific file
 
347
    file_weave = branch.repository.weave_store.get_weave(file_id,
 
348
                branch.repository.get_transaction())
 
349
    weave_modifed_revisions = set(file_weave.versions())
 
350
    # build the ancestry of each revision in the graph
 
351
    # - only listing the ancestors that change the specific file.
 
352
    rev_graph = branch.repository.get_revision_graph(mainline_revisions[-1])
 
353
    sorted_rev_list = topo_sort(rev_graph)
 
354
    ancestry = {}
 
355
    for rev in sorted_rev_list:
 
356
        parents = rev_graph[rev]
 
357
        if rev not in weave_modifed_revisions and len(parents) == 1:
 
358
            # We will not be adding anything new, so just use a reference to
 
359
            # the parent ancestry.
 
360
            rev_ancestry = ancestry[parents[0]]
 
361
        else:
 
362
            rev_ancestry = set()
 
363
            if rev in weave_modifed_revisions:
 
364
                rev_ancestry.add(rev)
 
365
            for parent in parents:
 
366
                rev_ancestry = rev_ancestry.union(ancestry[parent])
 
367
        ancestry[rev] = rev_ancestry
 
368
 
 
369
    def is_merging_rev(r):
 
370
        parents = rev_graph[r]
 
371
        if len(parents) > 1:
 
372
            leftparent = parents[0]
 
373
            for rightparent in parents[1:]:
 
374
                if not ancestry[leftparent].issuperset(
 
375
                        ancestry[rightparent]):
 
376
                    return True
 
377
        return False
 
378
 
 
379
    # filter from the view the revisions that did not change or merge 
 
380
    # the specific file
 
381
    return [(r, n, d) for r, n, d in view_revs_iter
 
382
            if r in weave_modifed_revisions or is_merging_rev(r)]
257
383
 
258
384
 
259
385
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
267
393
        if direction == 'reverse':
268
394
            revision_ids.reverse()
269
395
        for revision_id in revision_ids:
270
 
            yield revision_id, rev_nos[revision_id], 0
 
396
            yield revision_id, str(rev_nos[revision_id]), 0
271
397
        return
272
398
    merge_sorted_revisions = merge_sort(
273
399
        branch.repository.get_revision_graph(mainline_revs[-1]),
274
400
        mainline_revs[-1],
275
 
        mainline_revs)
 
401
        mainline_revs,
 
402
        generate_revno=True)
276
403
 
277
404
    if direction == 'forward':
278
405
        # forward means oldest first.
280
407
    elif direction != 'reverse':
281
408
        raise ValueError('invalid direction %r' % direction)
282
409
 
283
 
    revision_history = branch.revision_history()
284
 
 
285
 
    for sequence, rev_id, merge_depth, end_of_merge in merge_sorted_revisions:
286
 
        yield rev_id, rev_nos.get(rev_id), merge_depth
 
410
    for sequence, rev_id, merge_depth, revno, end_of_merge in merge_sorted_revisions:
 
411
        yield rev_id, '.'.join(map(str, revno)), merge_depth
287
412
 
288
413
 
289
414
def reverse_by_depth(merge_sorted_revisions, _depth=0):
310
435
    return result
311
436
 
312
437
 
 
438
class LogRevision(object):
 
439
    """A revision to be logged (by LogFormatter.log_revision).
 
440
 
 
441
    A simple wrapper for the attributes of a revision to be logged.
 
442
    The attributes may or may not be populated, as determined by the 
 
443
    logging options and the log formatter capabilities.
 
444
    """
 
445
 
 
446
    def __init__(self, rev=None, revno=None, merge_depth=0, delta=None,
 
447
                 tags=None):
 
448
        self.rev = rev
 
449
        self.revno = revno
 
450
        self.merge_depth = merge_depth
 
451
        self.delta = delta
 
452
        self.tags = tags
 
453
 
 
454
 
313
455
class LogFormatter(object):
314
 
    """Abstract class to display log messages."""
 
456
    """Abstract class to display log messages.
 
457
 
 
458
    At a minimum, a derived class must implement the log_revision method.
 
459
 
 
460
    If the LogFormatter needs to be informed of the beginning or end of
 
461
    a log it should implement the begin_log and/or end_log hook methods.
 
462
 
 
463
    A LogFormatter should define the following supports_XXX flags 
 
464
    to indicate which LogRevision attributes it supports:
 
465
 
 
466
    - supports_delta must be True if this log formatter supports delta.
 
467
        Otherwise the delta attribute may not be populated.
 
468
    - supports_merge_revisions must be True if this log formatter supports 
 
469
        merge revisions.  If not, only revisions mainline revisions (those 
 
470
        with merge_depth == 0) will be passed to the formatter.
 
471
    - supports_tags must be True if this log formatter supports tags.
 
472
        Otherwise the tags attribute may not be populated.
 
473
    """
315
474
 
316
475
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
317
476
        self.to_file = to_file
318
477
        self.show_ids = show_ids
319
478
        self.show_timezone = show_timezone
320
479
 
 
480
# TODO: uncomment this block after show() has been removed.
 
481
# Until then defining log_revision would prevent _show_log calling show() 
 
482
# in legacy formatters.
 
483
#    def log_revision(self, revision):
 
484
#        """Log a revision.
 
485
#
 
486
#        :param  revision:   The LogRevision to be logged.
 
487
#        """
 
488
#        raise NotImplementedError('not implemented in abstract base')
 
489
 
 
490
    @deprecated_method(zero_seventeen)
321
491
    def show(self, revno, rev, delta):
322
492
        raise NotImplementedError('not implemented in abstract base')
323
493
 
324
494
    def short_committer(self, rev):
325
495
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
326
 
    
327
 
    
 
496
 
 
497
 
328
498
class LongLogFormatter(LogFormatter):
329
 
    def show(self, revno, rev, delta):
330
 
        return self._show_helper(revno=revno, rev=rev, delta=delta)
331
 
 
 
499
 
 
500
    supports_merge_revisions = True
 
501
    supports_delta = True
 
502
    supports_tags = True
 
503
 
 
504
    @deprecated_method(zero_seventeen)
 
505
    def show(self, revno, rev, delta, tags=None):
 
506
        lr = LogRevision(rev, revno, 0, delta, tags)
 
507
        return self.log_revision(lr)
 
508
 
 
509
    @deprecated_method(zero_eleven)
332
510
    def show_merge(self, rev, merge_depth):
333
 
        return self._show_helper(rev=rev, indent='    '*merge_depth, merged=True, delta=None)
334
 
 
335
 
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
336
 
        """Show a revision, either merged or not."""
 
511
        lr = LogRevision(rev, merge_depth=merge_depth)
 
512
        return self.log_revision(lr)
 
513
 
 
514
    @deprecated_method(zero_seventeen)
 
515
    def show_merge_revno(self, rev, merge_depth, revno, tags=None):
 
516
        """Show a merged revision rev, with merge_depth and a revno."""
 
517
        lr = LogRevision(rev, revno, merge_depth, tags=tags)
 
518
        return self.log_revision(lr)
 
519
 
 
520
    def log_revision(self, revision):
 
521
        """Log a revision, either merged or not."""
337
522
        from bzrlib.osutils import format_date
 
523
        indent = '    '*revision.merge_depth
338
524
        to_file = self.to_file
339
525
        print >>to_file,  indent+'-' * 60
340
 
        if revno is not None:
341
 
            print >>to_file,  'revno:', revno
342
 
        if merged:
343
 
            print >>to_file,  indent+'merged:', rev.revision_id
344
 
        elif self.show_ids:
345
 
            print >>to_file,  indent+'revision-id:', rev.revision_id
 
526
        if revision.revno is not None:
 
527
            print >>to_file,  indent+'revno:', revision.revno
 
528
        if revision.tags:
 
529
            print >>to_file, indent+'tags: %s' % (', '.join(revision.tags))
346
530
        if self.show_ids:
347
 
            for parent_id in rev.parent_ids:
 
531
            print >>to_file, indent+'revision-id:', revision.rev.revision_id
 
532
            for parent_id in revision.rev.parent_ids:
348
533
                print >>to_file, indent+'parent:', parent_id
349
 
        print >>to_file,  indent+'committer:', rev.committer
 
534
        print >>to_file, indent+'committer:', revision.rev.committer
 
535
 
350
536
        try:
351
537
            print >>to_file, indent+'branch nick: %s' % \
352
 
                rev.properties['branch-nick']
 
538
                revision.rev.properties['branch-nick']
353
539
        except KeyError:
354
540
            pass
355
 
        date_str = format_date(rev.timestamp,
356
 
                               rev.timezone or 0,
 
541
        date_str = format_date(revision.rev.timestamp,
 
542
                               revision.rev.timezone or 0,
357
543
                               self.show_timezone)
358
544
        print >>to_file,  indent+'timestamp: %s' % date_str
359
545
 
360
546
        print >>to_file,  indent+'message:'
361
 
        if not rev.message:
 
547
        if not revision.rev.message:
362
548
            print >>to_file,  indent+'  (no message)'
363
549
        else:
364
 
            message = rev.message.rstrip('\r\n')
 
550
            message = revision.rev.message.rstrip('\r\n')
365
551
            for l in message.split('\n'):
366
552
                print >>to_file,  indent+'  ' + l
367
 
        if delta is not None:
368
 
            delta.show(to_file, self.show_ids)
 
553
        if revision.delta is not None:
 
554
            revision.delta.show(to_file, self.show_ids)
369
555
 
370
556
 
371
557
class ShortLogFormatter(LogFormatter):
 
558
 
 
559
    supports_delta = True
 
560
 
 
561
    @deprecated_method(zero_seventeen)
372
562
    def show(self, revno, rev, delta):
 
563
        lr = LogRevision(rev, revno, 0, delta)
 
564
        return self.log_revision(lr)
 
565
 
 
566
    def log_revision(self, revision):
373
567
        from bzrlib.osutils import format_date
374
568
 
375
569
        to_file = self.to_file
376
 
        date_str = format_date(rev.timestamp, rev.timezone or 0,
377
 
                            self.show_timezone)
378
 
        print >>to_file, "%5d %s\t%s" % (revno, self.short_committer(rev),
379
 
                format_date(rev.timestamp, rev.timezone or 0,
 
570
        date_str = format_date(revision.rev.timestamp,
 
571
                               revision.rev.timezone or 0,
 
572
                               self.show_timezone)
 
573
        is_merge = ''
 
574
        if len(revision.rev.parent_ids) > 1:
 
575
            is_merge = ' [merge]'
 
576
        print >>to_file, "%5s %s\t%s%s" % (revision.revno,
 
577
                self.short_committer(revision.rev),
 
578
                format_date(revision.rev.timestamp,
 
579
                            revision.rev.timezone or 0,
380
580
                            self.show_timezone, date_fmt="%Y-%m-%d",
381
 
                           show_offset=False))
 
581
                            show_offset=False),
 
582
                is_merge)
382
583
        if self.show_ids:
383
 
            print >>to_file,  '      revision-id:', rev.revision_id
384
 
        if not rev.message:
 
584
            print >>to_file,  '      revision-id:', revision.rev.revision_id
 
585
        if not revision.rev.message:
385
586
            print >>to_file,  '      (no message)'
386
587
        else:
387
 
            message = rev.message.rstrip('\r\n')
 
588
            message = revision.rev.message.rstrip('\r\n')
388
589
            for l in message.split('\n'):
389
590
                print >>to_file,  '      ' + l
390
591
 
391
592
        # TODO: Why not show the modified files in a shorter form as
392
593
        # well? rewrap them single lines of appropriate length
393
 
        if delta is not None:
394
 
            delta.show(to_file, self.show_ids)
 
594
        if revision.delta is not None:
 
595
            revision.delta.show(to_file, self.show_ids)
395
596
        print >>to_file, ''
396
597
 
397
598
 
398
599
class LineLogFormatter(LogFormatter):
 
600
 
 
601
    def __init__(self, *args, **kwargs):
 
602
        from bzrlib.osutils import terminal_width
 
603
        super(LineLogFormatter, self).__init__(*args, **kwargs)
 
604
        self._max_chars = terminal_width() - 1
 
605
 
399
606
    def truncate(self, str, max_len):
400
607
        if len(str) <= max_len:
401
608
            return str
413
620
        else:
414
621
            return rev.message
415
622
 
 
623
    @deprecated_method(zero_seventeen)
416
624
    def show(self, revno, rev, delta):
417
625
        from bzrlib.osutils import terminal_width
418
626
        print >> self.to_file, self.log_string(revno, rev, terminal_width()-1)
419
627
 
 
628
    def log_revision(self, revision):
 
629
        print >>self.to_file, self.log_string(revision.revno, revision.rev,
 
630
                                              self._max_chars)
 
631
 
420
632
    def log_string(self, revno, rev, max_chars):
421
633
        """Format log info into one string. Truncate tail of string
422
634
        :param  revno:      revision number (int) or None.
428
640
        out = []
429
641
        if revno:
430
642
            # show revno only when is not None
431
 
            out.append("%d:" % revno)
 
643
            out.append("%s:" % revno)
432
644
        out.append(self.truncate(self.short_committer(rev), 20))
433
645
        out.append(self.date_string(rev))
434
646
        out.append(rev.get_summary())
439
651
    lf = LineLogFormatter(None)
440
652
    return lf.log_string(None, rev, max_chars)
441
653
 
442
 
FORMATTERS = {
443
 
              'long': LongLogFormatter,
444
 
              'short': ShortLogFormatter,
445
 
              'line': LineLogFormatter,
446
 
              }
 
654
 
 
655
class LogFormatterRegistry(registry.Registry):
 
656
    """Registry for log formatters"""
 
657
 
 
658
    def make_formatter(self, name, *args, **kwargs):
 
659
        """Construct a formatter from arguments.
 
660
 
 
661
        :param name: Name of the formatter to construct.  'short', 'long' and
 
662
            'line' are built-in.
 
663
        """
 
664
        return self.get(name)(*args, **kwargs)
 
665
 
 
666
    def get_default(self, branch):
 
667
        return self.get(branch.get_config().log_format())
 
668
 
 
669
 
 
670
log_formatter_registry = LogFormatterRegistry()
 
671
 
 
672
 
 
673
log_formatter_registry.register('short', ShortLogFormatter,
 
674
                                'Moderately short log format')
 
675
log_formatter_registry.register('long', LongLogFormatter,
 
676
                                'Detailed log format')
 
677
log_formatter_registry.register('line', LineLogFormatter,
 
678
                                'Log format with one line per revision')
 
679
 
447
680
 
448
681
def register_formatter(name, formatter):
449
 
    FORMATTERS[name] = formatter
 
682
    log_formatter_registry.register(name, formatter)
 
683
 
450
684
 
451
685
def log_formatter(name, *args, **kwargs):
452
686
    """Construct a formatter from arguments.
456
690
    """
457
691
    from bzrlib.errors import BzrCommandError
458
692
    try:
459
 
        return FORMATTERS[name](*args, **kwargs)
 
693
        return log_formatter_registry.make_formatter(name, *args, **kwargs)
460
694
    except KeyError:
461
695
        raise BzrCommandError("unknown log formatter: %r" % name)
462
696
 
 
697
 
463
698
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
464
699
    # deprecated; for compatibility
465
700
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
466
701
    lf.show(revno, rev, delta)
467
702
 
 
703
 
468
704
def show_changed_revisions(branch, old_rh, new_rh, to_file=None, log_format='long'):
469
705
    """Show the change in revision history comparing the old revision history to the new one.
470
706
 
505
741
        to_file.write('\nRemoved Revisions:\n')
506
742
        for i in range(base_idx, len(old_rh)):
507
743
            rev = branch.repository.get_revision(old_rh[i])
508
 
            lf.show(i+1, rev, None)
 
744
            lr = LogRevision(rev, i+1, 0, None)
 
745
            lf.log_revision(lr)
509
746
        to_file.write('*'*60)
510
747
        to_file.write('\n\n')
511
748
    if base_idx < len(new_rh):