← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff-delta.c

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-08-14 05:49:27 UTC
  • mfrom: (4476.3.86 inventory-delta)
  • Revision ID: pqm@pqm.ubuntu.com-20090814054927-k0k18dn46ax4b91f
(andrew) Add inventory-delta streaming for cross-format fetch.

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;
789
789
    entry = entries;
790
790
    num_inserted = 0;
791
791
    for (; num_entries > 0; --num_entries, ++entry) {
792
 
        struct index_entry *next_bucket_entry, *cur_entry, *bucket_first_entry;
793
792
        hash_offset = (entry->val & old_index->hash_mask);
794
793
        /* The basic structure is a hash => packed_entries that fit in that
795
794
         * hash bucket. Things are structured such that the hash-pointers are
798
797
         * forward. If there are no NULL targets, then we know because
799
798
         * entry->ptr will not be NULL.
800
799
         */
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--;
 
800
        old_entry = old_index->hash[hash_offset + 1];
 
801
        old_entry--;
 
802
        while (old_entry->ptr == NULL
 
803
               && old_entry >= old_index->hash[hash_offset]) {
 
804
            old_entry--;
809
805
        }
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) {
 
806
        old_entry++;
 
807
        if (old_entry->ptr != NULL
 
808
            || old_entry >= old_index->hash[hash_offset + 1]) {
814
809
            /* There is no room for this entry, we have to resize */
815
810
            // char buff[128];
816
811
            // get_text(buff, entry->ptr);
827
822
            break;
828
823
        }
829
824
        num_inserted++;
830
 
        *cur_entry = *entry;
 
825
        *old_entry = *entry;
831
826
        /* For entries which we *do* manage to insert into old_index, we don't
832
827
         * want them double copied into the final output.
833
828
         */
853
848
    free(index);
854
849
}
855
850
 
856
 
unsigned long
857
 
sizeof_delta_index(struct delta_index *index)
 
851
unsigned long sizeof_delta_index(struct delta_index *index)
858
852
{
859
853
    if (index)
860
854
        return index->memsize;
873
867
             const void *trg_buf, unsigned long trg_size,
874
868
             unsigned long *delta_size, unsigned long max_size)
875
869
{
876
 
    unsigned int i, outpos, outsize, moff, val;
877
 
    int msize;
 
870
    unsigned int i, outpos, outsize, moff, msize, val;
878
871
    const struct source_info *msource;
879
872
    int inscnt;
880
873
    const unsigned char *ref_data, *ref_top, *data, *top;
945
938
                 entry++) {
946
939
                const unsigned char *ref;
947
940
                const unsigned char *src;
948
 
                int ref_size;
 
941
                unsigned int ref_size;
949
942
                if (entry->val != val)
950
943
                    continue;
951
944
                ref = entry->ptr;
958
951
                 * match more bytes with this location that we have already
959
952
                 * matched.
960
953
                 */
961
 
                if (ref_size > (top - src))
 
954
                if (ref_size > top - src)
962
955
                    ref_size = top - src;
963
956
                if (ref_size <= msize)
964
957
                    break;
965
958
                /* See how many bytes actually match at this location. */
966
959
                while (ref_size-- && *src++ == *ref)
967
960
                    ref++;
968
 
                if (msize < (ref - entry->ptr)) {
 
961
                if (msize < ref - entry->ptr) {
969
962
                    /* this is our best match so far */
970
963
                    msize = ref - entry->ptr;
971
964
                    msource = entry->src;