/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/diff-delta.c

  • Committer: John Arbash Meinel
  • Date: 2009-04-21 23:54:16 UTC
  • mto: (4300.1.7 groupcompress_info)
  • mto: This revision was merged to the branch mainline in revision 4301.
  • Revision ID: john@arbash-meinel.com-20090421235416-f0cz6ilf5cufbugi
https://launchpad.net/bugs/364900
Fix bug #364900, properly remove the 64kB that was just encoded in the copy.
Also, stop supporting None as a copy length in 'encode_copy_instruction'.
It was only used by the test suite, and it is good to pull that sort of thing out of
production code. (Besides, setting the copy to 64kB has the same effect.)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff-delta.c
688
688
    const unsigned char *data, *buffer, *top;
689
689
    unsigned char cmd;
690
690
    struct delta_index *new_index;
691
 
    struct index_entry *entry, *entries;
 
691
    struct index_entry *entry, *entries, *old_entry;
692
692
 
693
693
    if (!src->buf || !src->size)
694
694
        return NULL;
713
713
    prev_val = ~0;
714
714
    data = buffer;
715
715
    /* target size */
716
 
    /* get_delta_hdr_size doesn't mutate the content, just moves the
717
 
     * start-of-data pointer, so it is safe to do the cast.
718
 
     */
719
 
    get_delta_hdr_size((unsigned char**)&data, top);
 
716
    get_delta_hdr_size(&data, top);
720
717
    entry = entries; /* start at the first slot */
721
718
    num_entries = 0; /* calculate the real number of entries */
722
719
    while (data < top) {
789
786
    entry = entries;
790
787
    num_inserted = 0;
791
788
    for (; num_entries > 0; --num_entries, ++entry) {
792
 
        struct index_entry *next_bucket_entry, *cur_entry, *bucket_first_entry;
793
789
        hash_offset = (entry->val & old_index->hash_mask);
794
790
        /* The basic structure is a hash => packed_entries that fit in that
795
791
         * hash bucket. Things are structured such that the hash-pointers are
798
794
         * forward. If there are no NULL targets, then we know because
799
795
         * entry->ptr will not be NULL.
800
796
         */
801
 
        // The start of the next bucket, this may point past the end of the
802
 
        // entry table if hash_offset is the last bucket.
803
 
        next_bucket_entry = old_index->hash[hash_offset + 1];
804
 
        // First entry in this bucket
805
 
        bucket_first_entry = old_index->hash[hash_offset];
806
 
        cur_entry = next_bucket_entry - 1;
807
 
        while (cur_entry->ptr == NULL && cur_entry >= bucket_first_entry) {
808
 
            cur_entry--;
 
797
        old_entry = old_index->hash[hash_offset + 1];
 
798
        old_entry--;
 
799
        while (old_entry->ptr == NULL
 
800
               && old_entry >= old_index->hash[hash_offset]) {
 
801
            old_entry--;
809
802
        }
810
 
        // cur_entry now either points at the first NULL, or it points to
811
 
        // next_bucket_entry if there were no blank spots.
812
 
        cur_entry++;
813
 
        if (cur_entry >= next_bucket_entry || cur_entry->ptr != NULL) {
 
803
        old_entry++;
 
804
        if (old_entry->ptr != NULL
 
805
            || old_entry >= old_index->hash[hash_offset + 1]) {
814
806
            /* There is no room for this entry, we have to resize */
815
807
            // char buff[128];
816
808
            // get_text(buff, entry->ptr);
827
819
            break;
828
820
        }
829
821
        num_inserted++;
830
 
        *cur_entry = *entry;
 
822
        *old_entry = *entry;
831
823
        /* For entries which we *do* manage to insert into old_index, we don't
832
824
         * want them double copied into the final output.
833
825
         */